最近想复习下C++，很久没怎么用了，毕业时的一些经典排序算法也忘差不多了，所以刚好一起再学习一遍。
除了冒泡、插入、选择这几个复杂度O(n^2)的基本排序算法，希尔、归并、快速、堆排序，多多少少还有些晦涩难懂，幸好又博客园大神dreamcatcher-cx都总结成了图解，一步步很详细，十分感谢。
而且就时间复杂度来说，这几种算法到底有什么区别呢，刚好做了下测试。
代码参考: http://yansu.org/2015/09/07/sort-algorithms.html
//: basic_sort #include <iostream> #include <vector> #include <ctime> #include <string> using namespace std; // 获取函数名字的宏 #define GET_NAME(x) #x // 生成随机数的宏 #define random(a,b) (rand()%(b-a+1)+a) // 打印容器对象(vector)的宏 #define PRT(nums) { \ for(int i =0; i<nums.size(); i++){ \ cout << nums[i] << " "; \ }\ } /* 冒泡排序 基本思想: 对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会将最小或最大的元素“浮”到顶端，最终达到完全有序 图解: http://www.cnblogs.com/chengxiao/p/6103002.html 考的最多的排序了吧。 1. 两层循环，最里面判断两个数的大小，大的换到后面(正序) 2. 内部循环一遍后，最大的数已经到最后面了 3. 下一次内部循环从0到倒数第二个数(最后一个数通过第一步循环比较已经最大了) 4. 依次循环下去 时间复杂度O(n^2)，空间复杂度是O(n) */ void bubble_sort(vector<int> &nums) { for (int i = 0; i < nums.size() - 1; i++) { // i用来控制已经冒泡的数字个数 for (int j = 0; j < nums.size() - i - 1; j++) { // 从最左边遍历到最后一个没有浮动的数字 if (nums[j] > nums[j + 1]) { nums[j] += nums[j + 1]; nums[j + 1] = nums[j] - nums[j + 1]; nums[j] -= nums[j + 1]; } } } } /* 插入排序 基本思想: 每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。 图解: http://www.cnblogs.com/chengxiao/p/6103002.html 1. 两层循环，第一层i表示从左开始已经排好虚的部分 2. 第二层循环，将当前的数以及它前面的所有数两两比较，交换大的数到后面(正序) 3. 保证前面的数是排序好的，将新读取的数通过遍历前面排好序的部分并比较，插入到合适的位置 时间复杂度O(n^2)，空间复杂度是O(n) */ void insert_sort(vector<int> &nums) { for (int i = 1; i < nums.size(); i++) { // i表示从左开始已经排好序的部分 for (int j = i; j > 0; j--) { // 从当前数字位置遍历到最左边的数字位置 if (nums[j] < nums[j - 1]) { int temp = nums[j]; nums[j] = nums[j - 1]; nums[j - 1] = temp; } } } } /* 选择排序 图解: http://www.cnblogs.com/chengxiao/p/6103002.html 基本思想: 每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素 1. 两层循环，第一层从左到右遍历，读取当前的数 2. min存放最小元素，初始化为当前数字 3. 内部循环遍历和比较当前数字后后面所有数字的大小，如果有更小的，替换min为更小数字的位置 4. 内部遍历之后检查min是否变化，如果变化，说明最小的数字不在之前初始化的min位置，交换使每次循环最小的元素被移动到最左边。 时间复杂度O(n^2)，空间复杂度是O(n) */ void selection_sort(vector<int> &nums) { for (int i = 0; i < nums.size(); i++) { // 从左到右遍历所有数字 int min = i; // 每一趟循环比较时，min用于存放较小元素的数组下标，这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标，避免每次遇到较小元素都要进行交换。 for (int j = i + 1; j < nums.size(); j++) { if (nums[j] < nums[min]) { min = j; } } if (min != i) { //进行交换，如果min发生变化，则进行交换 int temp = nums[i]; nums[i] = nums[min]; nums[min] = temp; } } } /* 希尔排序 图解: http://www.cnblogs.com/chengxiao/p/6104371.html 基本思想: 希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。 1. 最外层循环设置间隔(gap)，按常规取gap=length/2，并以gap = gap/2的方式缩小增量 2. 第二个循环从gap位置向后遍历，读取当前元素 3. 第三个循环从当前元素所在分组的上一个元素开始(即减去gap的位置)，通过递减gap向前遍历分组内的元素，其实就是比较分组内i和i-gap元素的大小，交换大的到后面 希尔排序的时间复杂度受步长的影响，不稳定。 */ void shell_sort(vector<int> &nums) { for (int gap = int(nums.size()) >> 1; gap > 0; gap >>= 1) { // 遍历gap for (int i = gap; i < nums.size(); i++) { // 从第gap个元素向后遍历，逐个对其所在组进行直接插入排序操作 int j = i - gap; // j是这个分组内i元素的上一个元素 for (; j >= 0 && nums[j] > nums[i]; j -= gap) { // 从i向前遍历这个分组内所有元素，把大的交换到后面 swap(nums[j + gap], nums[j]); } } } } // 合并两个有序序列 void merge_array(vector<int> &nums, int b, int m, int e, vector<int> &temp) { // cout << "b: " << b << " " << "m: " << m << " " << "e: " << e << endl; int lb = b, rb = m, tb = b; while (lb != m && rb != e) if (nums[lb] < nums[rb]) temp[tb++] = nums[lb++]; else temp[tb++] = nums[rb++]; while (lb < m) temp[tb++] = nums[lb++]; while (rb < e) temp[tb++] = nums[rb++]; for (int i = b;i < e; i++) nums[i] = temp[i]; // cout << "temp: "; // PRT(temp); // cout << endl; } //递归对序列拆分，从b(开始)到e(结束)的序列，取中间点(b + e) / 2拆分 void merge_sort_recur(vector<int> &nums, int b, int e, vector<int> &temp) { int m = (b + e) / 2; // 取中间位置m if (m != b) { merge_sort_recur(nums, b, m, temp); merge_sort_recur(nums, m, e, temp); merge_array(nums, b, m, e, temp); // 开始(b)到中间(m) 和 中间(m)到结束(e) 两个序列传给合并函数 } } /* 归并排序 图解: http://www.cnblogs.com/chengxiao/p/6194356.html 基本思想: 利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 1. 合并两个有序序列的函数，合并后结果存入临时的temp 2. 从中间分，一直递归分到最小序列，即每个序列只有一个元素，单位为1(一个元素肯定是有序的) 3. 然后两两比较合并成单位为2的n/2个子数组，在结果上继续两两合并 时间复杂度是O(nlogn)，空间复杂度是O(n)。 */ void merge_sort(vector<int> &nums){ vector<int> temp; temp.insert(temp.begin(), nums.size(), 0); // 定义和初始化temp用于保存合并的中间序列 merge_sort_recur(nums, 0, int(nums.size()), temp); } // 将启始位置b作为基准，大于基准的数移动到右边，小于基准的数移动到左边 void quick_sort_recur(vector<int> &nums, int b, int e) { if (b < e - 1) { int lb = b, rb = e - 1; while (lb < rb) { // 遍历一遍，把大于基准的数移动到右边，小于基准的数移动到左边 while (nums[rb] >= nums[b] && lb < rb) //默认第一个数nums[b]作为基准 rb--; while (nums[lb] <= nums[b] && lb < rb) lb++; swap(nums[lb], nums[rb]); } swap(nums[b], nums[lb]); // cout << "nums: "; // PRT(nums); // cout << endl; quick_sort_recur(nums, b, lb); quick_sort_recur(nums, lb + 1, e); } } /* 快速排序 图解: http://www.cnblogs.com/chengxiao/p/6262208.html 基本思想: 快速排序也是利用分治法实现的一个排序算法。快速排序和归并排序不同，它不是一半一半的分子数组，而是选择一个基准数，把比这个数小的挪到左边，把比这个数大的移到右边。然后不断对左右两部分也执行相同步骤，直到整个数组有序。 1. 用一个基准数将数组分成两个子数组，取第一个数为基准 2. 将大于基准数的移到右边，小于的移到左边 3. 递归的对子数组重复执行1，2，直到整个数组有序 空间复杂度是O(n)，时间复杂度不稳定。 */ void quick_sort(vector<int> &nums){ quick_sort_recur(nums, 0, int(nums.size())); } // 调整单个二叉树的根节点和左右子树的位置，构建大顶堆 // 在左右子树中挑出最大的和根节点比较，把最大的数放在根节点即可 void max_heapify(vector<int> &nums, int root, int end) { int curr = root; // 根结点 int child = curr * 2 + 1; // 左子树 while (child < end) { if (child + 1 < end && nums[child] < nums[child + 1]) { child++; } if (nums[curr] < nums[child]) { int temp = nums[curr]; nums[curr] = nums[child]; nums[child] = temp; curr = child; child = 2 * curr + 1; } else { break; } } } /* 堆排序 图解: http://www.cnblogs.com/chengxiao/p/6262208.html 基本思想: 将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了 堆的概念(i是一个二叉树的根节点位置，2i+1和2i+2分别是左右子树)： 大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2] 小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2] 1. 由底(最后一个有叶子的根节点n/2-1)自上构建大顶堆 2. 根节点(0)和末尾交换，末尾变为最大 3. 对余下的0到n-1个数的根节点(0)二叉树进行大顶堆调整(调用max_heapify)(根节点(0)的叶子节点已经大于下面的所有数字了) 堆执行一次调整需要O(logn)的时间，在排序过程中需要遍历所有元素执行堆调整，所以最终时间复杂度是O(nlogn)。空间复杂度是O(n)。 */ void heap_sort(vector<int> &nums) { int n = int(nums.size()); for (int i = n / 2 - 1; i >= 0; i--) { // 构建大顶堆 max_heapify(nums, i, n); } for (int i = n - 1; i > 0; i--) { // 排序, 将第一个节点和最后一个节点交换，确保最后一个节点最大 int temp = nums[i]; nums[i] = nums[0]; nums[0] = temp; max_heapify(nums, 0, i); // 重新调整最顶部的根节点 } } void func_excute(void(* func)(vector<int> &), vector<int> nums, string func_name){ clock_t start, finish; start=clock(); (*func)(nums); finish=clock(); // PRT(nums); // 打印每次的排序结果 cout << endl; cout << func_name << "耗时：" << float(finish-start)/float(CLOCKS_PER_SEC)*1000 << " (ms) "<< endl; } int main() { vector<int> b; srand((unsigned)time(NULL)); for(int i=0;i<5000;i++) b.insert(b.end(), random(1,100)); cout << "数组长度: " << b.size() << "; "; // PRT(b); // 打印随机数组 cout << endl; void (*pFun)(vector<int> &); string func_name; pFun = bubble_sort; func_name = GET_NAME(bubble_sort); func_excute(pFun, b, func_name); pFun = insert_sort; func_name = GET_NAME(insert_sort); func_excute(pFun, b, func_name); pFun = selection_sort; func_name = GET_NAME(selection_sort); func_excute(pFun, b, func_name); pFun = shell_sort; func_name = GET_NAME(shell_sort); func_excute(pFun, b, func_name); pFun = merge_sort; func_name = GET_NAME(merge_sort); func_excute(pFun, b, func_name); pFun = quick_sort; func_name = GET_NAME(quick_sort); func_excute(pFun, b, func_name); pFun = heap_sort; func_name = GET_NAME(heap_sort); func_excute(pFun, b, func_name); } ///:~
在数组很小的情况下，没有太大区别。但是较长数组，考的最多的冒泡排序就明显比较吃力了～
具体原因只能从时间复杂度上面来看，但为什么差这么多，我也不是完全明白～
运行结果，排序算法分别耗时:
数组长度: 5000; bubble_sort耗时：183.4 (ms) insert_sort耗时：106.525 (ms) selection_sort耗时：68.036 (ms) shell_sort耗时：1.096 (ms) merge_sort耗时：1.226 (ms) quick_sort耗时：1.398 (ms) heap_sort耗时：1.514 (ms) Program ended with exit code: 0
