算法初学者指南：理解排序算法

CCSBRIDGE2024-01-12 21:27

前言

排序是计算机科学中的基本问题之一，也是数据处理的核心步骤。从最简单的个人项目到复杂的工业级应用，排序都扮演着关键角色。本文将介绍四种常见的排序算法：冒泡排序、插入排序、快速排序和堆排序，旨在帮助算法初学者理解这些基本概念。

快速理解

冒泡排序

冒泡排序是最简单的排序算法之一，它重复遍历要排序的列表，比较相邻的元素，并将顺序错误的元素交换位置。这个过程重复进行，直到没有需要交换的元素，这时列表就排序完成了。

算法步骤：

  1. 从列表的第一个元素开始，比较相邻的元素。
  2. 如果第一个元素比第二个大，就交换它们的位置。
  3. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  4. 针对所有的元素重复以上的步骤，除了最后一个。
  5. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

尽管冒泡排序很直观，但它不适合处理大数据集。它的平均和最坏情况时间复杂度均为O(n²)，其中n是列表的元素数量。

插入排序

插入排序的工作方式类似于我们排序扑克牌。在每次迭代中，插入排序从数据集中取出未排序部分的第一个元素，然后逐步将该元素移动到已排序部分的正确位置。

算法步骤：

  1. 从第一个元素开始，该元素被认为已经排序。
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描。
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置。
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置。
  5. 将新元素插入到该位置后。
  6. 重复步骤2~5。

对于较小的数据集，插入排序效果不错，平均和最坏情况的时间复杂度同样为O(n²)，但它在列表基本有序的情况下表现得尤为优秀。

快速排序

快速排序是一种分而治之的算法，以递归方式将列表分为较小的子列表。快速排序包含了两个主要的步骤：首先，选择一个"基准"项；其次，分区操作，将比基准小的项移到基准前面，比基准大的项移到后面。

算法步骤：

  1. 选择一个基准值。
  2. 分区过程中，比基准值小的移动到基准值的左边，比基准值大的移动到右边。
  3. 对左侧和右侧的两个子集，不包括基准值，重复步骤1和2。
  4. 重复步骤3，直到所有子集只剩下单个元素。

快速排序在平均和最佳情况下的时间复杂度为O(n log n)，但在最坏情况下会退化为O(n²)。不过在大多数情况下，它是非常高效的。

堆排序

堆排序是基于二叉堆数据结构的一种比较不同的排序方法。它利用了最大堆（或最小堆）的性质来排序元素。

算法步骤：

  1. 构建一个最大堆（或最小堆）。
  2. 将最大（或最小）项抽出并放置到集合的尾端。
  3. 重新调整剩余项，使其保持最大（或最小）堆的性质。
  4. 重复步骤2和3直到堆中只剩下一个元素。

堆排序的时间复杂度在最佳、平均和最坏情况下都是O(n log n)，并且它不需要额外的存储空间，这使它成为数据集较大时的一个不错的选择。

总结

学习这些排序算法为初学者提供了一种强有力的方式来理解算法分析的基本原则。虽然冒泡排序和插入排序由于其高时间复杂度在大数据集上效率较低，但它们简单且易于实现。快速排序因为平均性能好而被广泛使用，尽管它在最坏情况下的性能不佳。堆排序则提供了一种在所有情况下都很稳定的性能的排序方法。了解各个排序算法的优势和局限性将帮助你选择最适合你当前情况的算法。

附：算法题示例

1. 冒泡排序

题目： 给定一个整数数组，使用冒泡排序算法对其进行排序。

Python 示例答案：

python 复制代码 
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("Sorted array is:", arr)

C# 示例答案：

cs 复制代码 
using System;

public class BubbleSort {
    static void bubbleSort(int[] arr) {
        int n = arr.Length;
        for (int i = 0; i < n - 1; i++)
            for (int j = 0; j < n - i - 1; j++)
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
    }

    public static void Main() {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        Console.WriteLine("Sorted array:");
        foreach (int i in arr)
            Console.Write(i + " ");
    }
}

2. 插入排序

题目： 给定一个整数数组，使用插入排序算法对其进行排序。

Python 示例答案：

python 复制代码 
def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i-1
        while j >=0 and key < arr[j]:
                arr[j + 1] = arr[j]
                j -= 1
        arr[j + 1] = key
    return arr

arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("Sorted array is:", arr)

C# 示例答案：

cs 复制代码 
using System;

public class InsertionSort {
    static void insertionSort(int[] arr) {
        int n = arr.Length;
        for (int i = 1; i < n; ++i) {
            int key = arr[i];
            int j = i - 1;

            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j = j - 1;
            }
            arr[j + 1] = key;
        }
    }

    public static void Main() {
        int[] arr = {12, 11, 13, 5, 6};
        insertionSort(arr);
        Console.WriteLine("Sorted array:");
        foreach (int i in arr)
            Console.Write(i + " ");
    }
}

3. 快速排序

题目： 给定一个整数数组，使用快速排序算法对其进行排序。

Python 示例答案：

python 复制代码 
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

arr = [3, 6, 8, 10, 1, 2, 1]
print("Sorted array is:", quick_sort(arr))

C# 示例答案：

cs 复制代码 
using System;
using System.Linq;

public class QuickSort {
    public static void Main() {
        int[] arr = {3, 6, 8, 10, 1, 2, 1};
        var sortedArray = QuickSortArray(arr);
        Console.WriteLine("Sorted array:");
        foreach (int i in sortedArray)
            Console.Write(i + " ");
    }

    private static int[] QuickSortArray(int[] arr) {
        if (arr.Length <= 1)
            return arr;
        var pivot = arr[arr.Length / 2];
        var left = arr.Where(x => x < pivot).ToArray();
        var middle = arr.Where(x => x == pivot).ToArray();
        var right = arr.Where(x => x > pivot).ToArray();

        return QuickSortArray(left).Concat(middle).Concat(QuickSortArray(right)).ToArray();
    }
}

4. 堆排序

题目： 给定一个整数数组，使用堆排序算法对其进行排序。

Python 示例答案：

python 复制代码 
def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2
    if l < n and arr[i] < arr[l]:
        largest = l
    if r < n and arr[largest] < arr[r]:
        largest = r
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)
    return arr

arr = [12, 11, 13, 5, 6, 7]
heap_sort(arr)
print("Sorted array is:", arr)

C# 示例答案：

cs 复制代码 
using System;

public class HeapSort {
    public static void Main() {
        int[] arr = {12, 11, 13, 5, 6, 7};
        heapSort(arr);
        Console.WriteLine("Sorted array:");
        foreach (int i in arr)
            Console.Write(i + " ");
    }

    static void heapSort(int[] arr) {
        int n = arr.Length;
        for (int i = n / 2 - 1; i >= 0; i--)
            heapify(arr, n, i);
        for (int i = n - 1; i > 0; i--) {
            int temp = arr[0];
            arr[0] = arr[i];
            arr[i] = temp;
            heapify(arr, i, 0);
        }
    }

    static void heapify(int[] arr, int n, int i) {
        int largest = i;
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        if (left < n && arr[left] > arr[largest])
            largest = left;
        if (right < n && arr[right] > arr[largest])
            largest = right;
        if (largest != i) {
            int swap = arr[i];
            arr[i] = arr[largest];
            arr[largest] = swap;
            heapify(arr, n, largest);
        }
    }
}
相关推荐
为什么这亚子30 分钟前
九、Go语言快速入门之map
运维·开发语言·后端·算法·云原生·golang·云计算
待40 分钟前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习
～yY…s<#>1 小时前
【刷题17】最小栈、栈的压入弹出、逆波兰表达式
c语言·数据结构·c++·算法·leetcode
幸运超级加倍~2 小时前
软件设计师-上午题-16 算法(4-5分)
笔记·算法
yannan201903132 小时前
【算法】（Python）动态规划
python·算法·动态规划
埃菲尔铁塔_CV算法2 小时前
人工智能图像算法：开启视觉新时代的钥匙
人工智能·算法
EasyCVR2 小时前
EHOME视频平台EasyCVR视频融合平台使用OBS进行RTMP推流，WebRTC播放出现抖动、卡顿如何解决？
人工智能·算法·ffmpeg·音视频·webrtc·监控视频接入
linsa_pursuer2 小时前
快乐数算法
算法·leetcode·职场和发展
小芒果_012 小时前
P11229 [CSP-J 2024] 小木棍
c++·算法·信息学奥赛
qq_434085902 小时前
Day 52 || 739. 每日温度 、 496.下一个更大元素 I 、503.下一个更大元素II
算法
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解