浅析常用排序算法

1.排序算法的评价

涉及到时间复杂度(最差、平均、最好)

空间复杂度（需要额外的内存空间）

稳定性（两个相等键值R和S，原串R在S前，排序后R还在S前，称为稳定）

2.涉及到的排序算法

插入排序、冒泡排序、选择排序、快速排序、堆排序、归并排序、基数排序、希尔排序。

3.插入排序

源数据集：        64   5   7   89   5   24   32   18   40

初始化 ：         {64}   5   7   89   5   24   32   18   40

第一次排序：   {5   64}  7   89   5   24   32   18   40        

第二次排序      {5    7  64}   89   5   24   32   18   40

第三次排序      {5    7  64   89}   5   24   32   18   40

第四次排序      {5    5    7  64   89}  24   32   18   40

第五次排序      {5    5    7  24   64   89}  32   18   40

第六次排序      {5    5    7  24   32   64   89}  18   40

第七次排序      {5    5    7  18   24   32   64   89}  40

第八次排序      {5    5    7  18   24   32   64   89  40}

函数代码

template<class T>void InsertSort(T arr[], int len){for (int i = 0; i < len - 1; i++){int j = i;T temp = arr[i+1];while (temp < arr[j] && j >= 0){arr[j+1] = arr[j];j--;}arr[j+1] = temp;}}

时间复杂度： 最好情况 O(n)  最坏情况O(n*n) 平均情况O(n*n)

稳定性        ： 稳定

空间复杂度：O(1)

4. 冒泡排序

源数据集：        64   5   7   89   5    24   32   18   40

第一次排序：     5   7   64   5   24   32   18   40   89       

第二次排序        5    7   5    24  32   18    40   64  89

第三次排序        5    5   7   24   18   32    40  64  89 

第四次排序        5    5   7   18    24   32   40   64  89 

第五次排序        5    5    7  18    24   32   40   64  89

函数代码

template<class T>void BubbleSort(T arr[], int len){bool cmpFlag = true;for (int i = 0; i < len - 1 && cmpFlag; i++){cmpFlag = false;for (int j = 0; j < len - i - 1; j++){if (arr[j] > arr[j+1]){Swap(arr[j], arr[j+1]);cmpFlag = true;}}}}

时间复杂度： 最好情况O(n) 最坏情况O(n*n) 平均情况O(n*n)

稳定性：  稳定

空间复杂度：O(1)

5.选择排序

源数据集：        5    7   89   5    24   32   2   40

第一次排序：    2    7   89   5  24   32     5  40          //不稳定的例子

第二次排序        2    5   89   7   24   32   5   40

第三次排序        2    5   5    7   24    32   89  40

第四次排序       2     5   5    7   24    32   89  40

第五次排序       2     5   5    7   24    32   89   40

第六次排序       2     5   5    7   24    32   89   40

第七次排序       2     5  5    7   24    32   40   89

函数代码

template<class T>void SelectSort(T arr[], int len){for (int i = 0; i < len - 1; i++){T min = arr[i];int index = i;for (int j = i; j < len; j++){if (min > arr[j]){min = arr[j];index = j;}}if (index != i)Swap(arr[i], arr[index]);}}

时间复杂度：最好情况 O(n*n) 最坏情况O(n*n) 平均情况O(n*n)

稳定性： 不稳定

空间复杂度：O(1)

6.快速排序

源数据集：        64   5   7   89   5    24   32   18   40

第一次快排：    40   5   7   89    5   24   32    18  64

                            40   5   7   64    5   24   32    18  89

                            40   5   7   18    5   24   32    64  89

.....................

函数代码

template<class T>void QuickSort(T arr[], int len){QuickSort(arr, 0, len-1);}template<class T>void QuickSort(T arr[], int low, int high){if (low >= high)return;T key = arr[(low+high)/2];int i = low, j = high;while (i < j){while (i < j && arr[j] > key)j--;while (i < j && arr[i] < key)i++;if (i < j){Swap(arr[i], arr[j]);i++;j--;}if (i >= j)break;}QuickSort(arr, low, j);QuickSort(arr, j+1, high);}

时间复杂度：最好情况O(nlog2n) 最坏情况O(n*n) 平均情况O(nlog2n)

稳定性：不稳定

空间复杂度： 平均O(log2n)

7.堆排序

函数代码

template<class T>void CreateHeap(T arr[], int n, int h){int i = h;int j = 2 * i + 1;T temp = arr[i];bool flag = true;while (j < n && flag){if (j < n - 1 && arr[j] < arr[j+1])j++;if (temp > arr[j]){flag = false;}else{arr[i] = arr[j];i = j;j = 2 * i + 1;}}arr[i] = temp;}template<class T>void InitCreateHeap(T arr[], int len){for (int i = (len - 1) / 2; i >=0; i--)CreateHeap(arr, len,i);}template<class T>void HeapSort(T arr[], int len){InitCreateHeap(arr, len);for (int i = len - 1; i > 0; i--){T temp = arr[0];arr[0] = arr[i];arr[i] = temp;CreateHeap(arr, i, 0);}}

时间复杂度： 最好情况 O(nlog2n)  最坏情况O(nlog2n) 平均O(nlog2n)

稳定性:          不稳定

空间复杂度:   O(1)

8. 归并排序

源数据集：        64   5   7   89   5    24   32   18   40

第一次归并：     5  64    7   89   5    24   18   32   40

第二次归并：     5   7    64  89    5   18   24    32   40

第三次归并：    5     5    7   18   24   32  64     89   40

第四次归并：    5     5    7   18  24    32   40     64   89

函数代码：略

时间复杂度：O(nlog2n)

稳定性： 稳定

空间复杂度: O(n)

9. 基数排序

基数排序

时间复杂度 O(d(n+radix))

稳定性 : 稳定

空间复杂度 O(radix)

10. 希尔排序

时间复杂度 O(n^(1-2之间)）

稳定性   不稳定

空间复杂度  O(1)

11. 小结