十大经典排序算法动画与解析

Posted on | In

排序算法是《数据结构与算法》中最基本的算法之一

排序算法可以分为内部排序和外部排序。

内部排序是数据记录在内存中进行排序。

而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

用一张图概括：

640

关于时间复杂度：**

  1. 平方阶(O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
  2. 线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；
  3. O(n1+§)) 排序，§ 是介于0 和 1之间的常数。 希尔排序
  4. 线性阶(O(n)) 排序 基数排序，此外还有桶、箱排序。

关于稳定性：

  1. 稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
  2. 不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。

1. 冒泡排序

1.1 算法步骤

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

1.2 动画演示

2

1.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void BubbleSort1(int *arr,int sz)
{
    for(int i=0;i<sz-1;i++){
        for(int j=0;j<sz-i-1;j++){
             if(arr[j]>arr[j+1]){
                
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            
            }
        }
    }
}

2. 选择排序

2.1 算法步骤

  • 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
  • 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  • 重复第二步，直到所有元素均排序完毕。

2.2 动画演示

3

2.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
using namespace std;

void SelectSort(int *pData,int size)
{
    for(int i = 0;i<size-1;++i)
    {
        int index = i;
        for(int j = i+1;j<size;++j)
        {
            if(pData[j]<pData[index])
                index = j;
        }
        if(index != i)
        {
            int temp = pData[i];
            pData[i] = pData[index];
            pData[index] = temp;
        }
    }
}

int main()
{
    int pData[10]={1,5,9,3,4,7,8,2,6,10};
    for(int i = 0;i<10;++i)
        cout<<pData[i]<<' ';
    cout<<endl;
    SelectSort(pData,10);
    for(int i = 0;i<10;++i)
        cout<<pData[i]<<' ';
        
    return 0;
}

3. 插入排序

3.1 算法步骤

  • 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
  • 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

3.2 动画演示

4

3.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>
using namespace std;
void InsertSort(int *a, int n)
{
    for (int j = 1; j < n; j++)
    {
        int key = a[j]; //待排序第一个元素
        int i = j - 1;  //代表已经排过序的元素最后一个索引数
        while (i >= 0 && key < a[i])
        {
            //从后向前逐个比较已经排序过数组，如果比它小，则把后者用前者代替，
            //其实说白了就是数组逐个后移动一位,为找到合适的位置时候便于Key的插入
            a[i + 1] = a[i];
            i--;
        }
        a[i + 1] = key; //找到合适的位置了，赋值,在i索引的后面设置key值。
    }
}
int main()
{
    int d[] = {12, 15, 9, 20, 6, 31, 24};
    cout << "排序前数组：12, 15, 9, 20, 6, 31, 24, " << endl;
    InsertSort(d, 7);
    cout << "排序后结果：";
    for (int i = 0; i < 7; i++)
    {
        cout << d[i] <<","<< " ";
    }
    return 0;
}

4. 希尔排序

4.1 算法步骤

  • 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
  • 按增量序列个数 k，对序列进行 k 趟排序；
  • 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 动画演示

5

4.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <iostream>
using namespace std;

int shellSort(int arr[], int n)
{
    // 从一个大的Gap开始， 不断缩小Gao
    for (int gap = n / 2; gap > 0; gap /= 2)
    {
        // 对此间隙大小执行有缺口的插入排序。
        // 第一个间隙元素a[0..gap-1]已经是有间隙的顺序
        // 继续添加一个元素，直到整个数组都进行了间隙排序
        for (int i = gap; i < n; i += 1)
        {
            // 在已经进行间隙排序的元素中添加 a[i]
            // 在temp中保存 a[i] 并在第i个位置留个空隙
            int temp = arr[i];

            // 移动较早经过Gap-Sort的元素移动直到a[i]的位置被找到
            int j;
            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap)
                arr[j] = arr[j - gap];

            // 把temp(原来的a[i])放到正确的位置
            arr[j] = temp;
        }
    }
    return 0;
}
void printArray(int arr[], int n)
{
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}

int main()
{
    int arr[] = {12, 34, 54, 2, 3, 10}, i;
    //数组长度计算
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "排序前的数组: \n";
    printArray(arr, n);

    shellSort(arr, n);

    cout << "\n排序后的数组: \n";
    printArray(arr, n);

    return 0;
}

5. 归并排序

5.1 算法步骤

  • 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
  • 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
  • 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
  • 重复步骤 3 直到某一指针达到序列尾；
  • 将另一序列剩下的所有元素直接复制到合并序列尾。

5.2 动画演示

6

5.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

/* Merge sort in C++ */
#include <cstdio>
#include <iostream>
 
using namespace std;
 
// Function to Merge Arrays L and R into A.
// lefCount = number of elements in L
// rightCount = number of elements in R.
void Merge(int *A,int *L,int leftCount,int *R,int rightCount) {
	int i,j,k;
 
	// i - to mark the index of left aubarray (L)
	// j - to mark the index of right sub-raay (R)
	// k - to mark the index of merged subarray (A)
	i = 0; j = 0; k =0;
 
	while(i<leftCount && j< rightCount) {
		if(L[i]  < R[j]) A[k++] = L[i++];
		else A[k++] = R[j++];
	}
	while(i < leftCount) A[k++] = L[i++];
	while(j < rightCount) A[k++] = R[j++];
}
 
// Recursive function to sort an array of integers.
void MergeSort(int *A,int n) {
	int mid,i, *L, *R;
	if(n < 2) return; // base condition. If the array has less than two element, do nothing.
 
	mid = n/2;  // find the mid index.
 
	// create left and right subarrays
	// mid elements (from index 0 till mid-1) should be part of left sub-array
	// and (n-mid) elements (from mid to n-1) will be part of right sub-array
	L = new int[mid];
	R = new int [n - mid];
 
	for(i = 0;i<mid;i++) L[i] = A[i]; // creating left subarray
	for(i = mid;i<n;i++) R[i-mid] = A[i]; // creating right subarray
 
	MergeSort(L,mid);  // sorting the left subarray
	MergeSort(R,n-mid);  // sorting the right subarray
	Merge(A,L,mid,R,n-mid);  // Merging L and R into A as sorted list.
	// the delete operations is very important
	delete [] R;
	delete [] L;
}
 
int main() {
	/* Code to test the MergeSort function. */
 
	int A[] = {6,2,3,1,9,10,15,13,12,17}; // creating an array of integers.
	int i,numberOfElements;
 
	// finding number of elements in array as size of complete array in bytes divided by size of integer in bytes.
	// This won't work if array is passed to the function because array
	// is always passed by reference through a pointer. So sizeOf function will give size of pointer and not the array.
	// Watch this video to understand this concept - http://www.youtube.com/watch?v=CpjVucvAc3g
	numberOfElements = sizeof(A)/sizeof(A[0]);
 
	// Calling merge sort to sort the array.
	MergeSort(A,numberOfElements);
 
	//printing all elements in the array once its sorted.
	for(i = 0;i < numberOfElements;i++)
	   cout << " " << A[i];
	return 0;
}

6. 快速排序

6.1 算法步骤

  • 从数列中挑出一个元素，称为 “基准”（pivot）;
  • 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  • 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

6.2 动画演示

7

6.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include <iostream>
#include <stdio.h>
using namespace std;

/* low  --> Starting index,  high  --> Ending index */

void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

/* This function takes last element as pivot, places 
   the pivot element at its correct position in sorted 
    array, and places all smaller (smaller than pivot) 
   to left of pivot and all greater elements to right 
   of pivot */
int partition(int arr[], int low, int high)
{
    int pivot = arr[high]; // pivot
    int i = (low - 1);     // Index of smaller element

    for (int j = low; j <= high - 1; j++)
    {
        // If current element is smaller than or
        // equal to pivot
        if (arr[j] <= pivot)
        {
            i++; // increment index of smaller element
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

/* The main function that implements QuickSort 
 arr[] --> Array to be sorted, 
  low  --> Starting index, 
  high  --> Ending index */
void quickSort(int arr[], int low, int high)
{
    if (low < high)
    {
        /* pi is partitioning index, arr[p] is now 
           at right place */
        int pi = partition(arr, low, high);

        // Separately sort elements before
        // partition and after partition
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}
/* Function to print an array */
void printArray(int arr[], int size)
{
    int i;
    for (i = 0; i < size; i++)
        printf("%d ", arr[i]);
    printf("\n");
}

// Driver program to test above functions
int main()
{
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1);
    printf("Sorted array: \n");
    printArray(arr, n);
    return 0;
}

7. 堆排序

7.1 算法步骤

  • 创建一个堆 H[0……n-1]；
  • 把堆首（最大值）和堆尾互换；
  • 把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
  • 重复步骤 2，直到堆的尺寸为 1。

7.2 动画演示

8

7.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <iostream>
#include <stdio.h>

using namespace std;

//辅助交换函数
void Swap(int &a, int &b)
{
    int temp = a;
    a = b;
    b = temp;
}

//堆排序的核心是建堆,传入参数为数组，根节点位置，数组长度
void Heap_build(int a[], int root, int length)
{
    int lchild = root * 2 + 1; //根节点的左子结点下标
    if (lchild < length)       //左子结点下标不能超出数组的长度
    {
        int flag = lchild;       //flag保存左右节点中最大值的下标
        int rchild = lchild + 1; //根节点的右子结点下标
        if (rchild < length)     //右子结点下标不能超出数组的长度(如果有的话)
        {
            if (a[rchild] > a[flag]) //找出左右子结点中的最大值
            {
                flag = rchild;
            }
        }
        if (a[root] < a[flag])
        {
            //交换父结点和比父结点大的最大子节点
            Swap(a[root], a[flag]);
            //从此次最大子节点的那个位置开始递归建堆
            Heap_build(a, flag, length);
        }
    }
}

void Heap_sort(int a[], int len)
{
    for (int i = len / 2; i >= 0; --i) //从最后一个非叶子节点的父结点开始建堆
    {
        Heap_build(a, i, len);
    }

    for (int j = len - 1; j > 0; --j) //j表示数组此时的长度，因为len长度已经建过了，从len-1开始
    {
        Swap(a[0], a[j]);    //交换首尾元素,将最大值交换到数组的最后位置保存
        Heap_build(a, 0, j); //去除最后位置的元素重新建堆，此处j表示数组的长度，最后一个位置下标变为len-2
    }
}
int main(int argc, char **argv)
{
 
    int a[10] = {12, 45, 748, 12, 56, 3, 89, 4, 48, 2};
    Heap_sort(a, 10);
    for (size_t i = 0; i != 10; ++i)
    {
        cout << a[i] << " ";
    }
   
    cout << endl;
 
    return 0;
}

8. 计数排序

8.1 算法步骤

  • 花O(n)的时间扫描一下整个序列 A，获取最小值 min 和最大值 max
  • 开辟一块新的空间创建新的数组 B，长度为 ( max - min + 1)
  • 数组 B 中 index 的元素记录的值是 A 中某元素出现的次数
  • 最后输出目标整数序列，具体的逻辑是遍历数组 B，输出相应元素以及对应的个数

8.2 动画演示

9

8.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// C Program for counting sort
#include <stdio.h>
#include <string.h>
#define RANGE 255

// The main function that sort the given string arr[] in
// alphabatical order
void countSort(char arr[])
{
    // The output character array that will have sorted arr
    char output[strlen(arr)];

    // Create a count array to store count of inidividul
    // characters and initialize count array as 0
    int count[RANGE + 1], i;
    memset(count, 0, sizeof(count));

    // Store count of each character
    for (i = 0; arr[i]; ++i)
        ++count[arr[i]];

    // Change count[i] so that count[i] now contains actual
    // position of this character in output array
    for (i = 1; i <= RANGE; ++i)
        count[i] += count[i - 1];

    // Build the output character array
    for (i = 0; arr[i]; ++i)
    {
        output[count[arr[i]] - 1] = arr[i];
        --count[arr[i]];
    }

    /* 
     For Stable algorithm  
     for (i = sizeof(arr)-1; i>=0; --i) 
    { 
        output[count[arr[i]]-1] = arr[i]; 
        --count[arr[i]]; 
    } 
     
    For Logic : See implementation 
    */

    // Copy the output array to arr, so that arr now
    // contains sorted characters
    for (i = 0; arr[i]; ++i)
        arr[i] = output[i];
}

// Driver program to test above function
int main()
{
    char arr[] = "geeksforgeeks"; //"applepp";

    countSort(arr);

    printf("Sorted character array is %sn", arr);
    return 0;
}

9. 桶排序

9.1 算法步骤

  • 设置固定数量的空桶。
  • 把数据放到对应的桶中。
  • 对每个不为空的桶中数据进行排序。
  • 拼接不为空的桶中数据，得到结果
  • 桶排序耗用较大的辅助空间，所需要的辅助空间一般与被排序的数列的最大值与最小值有关

9.2 动画演示

10

9.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
#include <vector>
#include <iostream>

using namespace std;

void bucketSort(vector<int> &vec)
{
    int length = vec.size();
    vector<int> buckets(length, 0); //准备一堆桶，容器的下标即待排序数组的键值或键值经过转化后的值
    //此时每个桶中都是没有放蛋的，所以都是0

    for (int i = 0; i < length; ++i)
    {
        buckets[vec[i]]++; //把每个蛋放入到对应的桶中
    }

    int index = 0;
    for (int i = 0; i < length; ++i)
    { //把蛋取出，空桶则直接跳过
        for (int j = 0; j < buckets[i]; j++)
        {
            vec[index++] = i;
        }
    }
}
//上例是直接将键值作为桶下标的程序，没有经过转化

int main()
{
    int a[10] = {0, 2, 5, 6, 3, 2, 5, 9, 5, 2};
    vector<int> vec(a, a + 10);

    bucketSort(vec);
    for (int i = 0; i < vec.size(); ++i)
    {
        cout << vec[i] << "   ";
    }
    return 0;
}

10. 基数排序

10.1 算法步骤

  • 将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零
  • 从最低位开始，依次进行一次排序
  • 从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列

10.2 动画演示

11

10.3 参考代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <iostream>
#include <vector>

using namespace std;

void countSort(vector<int> &vec, int exp)
{ //计数排序
    vector<int> range(10, 0);

    int length = vec.size();
    vector<int> tmpVec(length, 0);

    for (int i = 0; i < length; ++i)
    {
        range[(vec[i] / exp) % 10]++;
    }

    for (int i = 1; i < range.size(); ++i)
    {
        range[i] += range[i - 1]; //统计本应该出现的位置
    }

    for (int i = length - 1; i >= 0; --i)
    {
        tmpVec[range[(vec[i] / exp) % 10] - 1] = vec[i];
        range[(vec[i] / exp) % 10]--;
    }
    vec = tmpVec;
}

void radixSort(vector<int> &vec)
{
    int length = vec.size();
    int max = -1;
    for (int i = 0; i < length; ++i)
    { //提取出最大值
        if (vec[i] > max)
            max = vec[i];
    }

    //提取每一位并进行比较，位数不足的高位补0
    for (int exp = 1; max / exp > 0; exp *= 10)
        countSort(vec, exp);
}

int main()
{
    int a[10] = {53, 3, 542, 748, 14, 214, 154, 63, 616, 589};

    vector<int> vec(a, a + 10);
    radixSort(vec);

    for (int i = 0; i < vec.size(); ++i)
    {
        cout << vec[i] << "   ";
    }

    cout << endl;
    return 0;
}