排序算法总结
一篇很好的讲8大排序的博客
选择排序 (不稳定)
- 选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择中，如果当前元素比一个元素大，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中2个5的相对前后顺序就被破坏了，所以选择排序不是一个稳定的排序算法。
堆排序 (不稳定)
- 堆的结构是节点i的孩子为 2i 和 2i+1 节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。在一个长为n的序列，堆排序的过程,首先要根据floyd算法建堆，因此要从第n/2开始和其子节点共3个值选择最大(大顶堆)或者最小(小顶堆),这3个元素之间的选择当然不会破坏稳定性。但当为n/2-1, n/2-2,...1这些个父节点选择元素时，就会破坏稳定性。有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。所以，堆排序不是稳定的排序算法。
- eg：{5A,6,5B,7,8} --> {8,7,5B,5A,6} ,两个5的顺序颠倒了。
插入排序 (稳定)
- 插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，就是第一个元素。插入调用有序序列的search操作，该操作返回的是第一个大于该元素的位置，相等元素的前后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，所以插入排序是稳定的。
希尔排序 (不稳定)
- 希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序了，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比o(n^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
冒泡排序 (稳定)
- 冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
快速排序 (不稳定)
- 快速排序有两个方向，当a[i] <= a[center_index]，左边的i下标一直往右走，其中center_index是中枢元素的数组下标，一般取为数组第0个元素。
- 当a[j] > a[center_index]，右边的j下标一直往左走。如果i和j都走不动了，i <= j,交换a[i] 和 a[j],重复上面的过程，直到i>j。交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱.
- 比如序列为 5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j]交换的时刻。
归并排序 (稳定)
- 归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换),然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。
基数排序 (稳定)
- 基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
1.快速排序
#include<iostream>
#include<vector>
using namespace std;
void swap(int &p, int &q)
{
int temp;
temp = p;
p = q;
q = temp;
}
int partition(vector<int>&array, int lo, int hi){
swap(array[lo], array[lo + rand() % (hi - lo + 1)]);//产生[lo,hi]之间的一个随机数
int pivot = array[lo];
while (lo < hi){
//swap
while ((lo < hi) && pivot <= array[hi])
{
hi--;
}
//array[lo] = array[hi];
swap(array[lo], array[hi]);
while ((lo < hi) && pivot >= array[lo])
{
lo++;
}
//array[hi] = array[lo];
swap(array[lo], array[hi]);
}
//array[lo] = pivot;
return lo;
}
void quicksort(vector<int>&array, int lo, int hi){
if (hi - lo < 1)return;
int mi = partition(array, lo, hi);
quicksort(array, lo, mi-1);
quicksort(array, mi + 1, hi);
}
int partition(vector<int>&array, int lo, int hi){
int pivot = array[lo];
while (lo < hi){
while (lo < hi&&pivot <= array[hi])hi--;
swap(array[lo], array[hi]);
while (lo < hi&&pivot >= array[lo])lo++;
swap(array[lo], array[hi]);
}
return lo;
}
/**使用栈的非递归快速排序**/
void quicksort2(vector<int> &vec, int low, int high){
stack<int> st;
if (low<high){
int mid = partition(vec, low, high);
if (low<mid - 1){
st.push(low);
st.push(mid - 1);
}
if (mid + 1<high){
st.push(mid + 1);
st.push(high);
}
//其实就是用栈保存每一个待排序子串的首尾元素下标，下一次while循环时取出这个范围，对这段子序列进行partition操作
while (!st.empty()){
int q = st.top();
st.pop();
int p = st.top();
st.pop();
mid = partition(vec, p, q);
if (p<mid - 1){
st.push(p);
st.push(mid - 1);
}
if (mid + 1<q){
st.push(mid + 1);
st.push(q);
}
}
}
}
2.归并排序
void merge(vector<int>&input, int left, int right, int mid, vector<int>&temp){
int i = left;
int j = mid+1;
int t = 0;
while (i<=mid&&j<=right){
if (input[i] <= input[j]){
temp[t++] = input[i++];
}
else{
temp[t++] = input[j++];
}
}
while (i <= mid){
temp[t++] = input[i++];
}
while (j <= right){
temp[t++] = input[j++];
}
t = 0;
while (left <= right){
input[left++] = temp[t++];
}
}
void mergesort(vector<int>&input, int left, int right, vector<int>&temp){
if (left < right){
int mid = (left + right) / 2;
mergesort(input, left, mid, temp);
mergesort(input, mid + 1, right, temp);
merge(input, left, right, mid, temp);
}
}
3.堆排序
/*
* (最大)堆的向下调整算法
*
* 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。数组是按层编号的。
* 其中，N为数组下标索引值，如数组中第1个数对应的N为0。
*
* 参数说明：
* a -- 待排序的数组
* start -- 被下调节点的起始位置(一般为0，表示从第1个开始)
* end -- 截至范围(一般为数组中最后一个元素的索引)
*/
void maxheap_down(int a[], int start, int end)
{
int c = start; // 当前(current)节点的位置
int l = 2*c + 1; // 左(left)孩子的位置
int tmp = a[c]; // 当前(current)节点的大小
for (; l <= end; c=l,l=2*l+1)
{
// "l"是左孩子，"l+1"是右孩子
if ( l < end && a[l] < a[l+1])
l++; // 左右两孩子中选择较大者，即m_heap[l+1]
if (tmp >= a[l])
break; // 调整结束
else // 交换值
{
a[c] = a[l];
a[l]= tmp;
}
}
}
/*
* 堆排序(从小到大)
*
* 参数说明：
* a -- 待排序的数组
* n -- 数组的长度
*/
void heap_sort_asc(int a[], int n)
{
int i;
// 从(n/2-1) --> 0逐次遍历。遍历之后，得到的数组实际上是一个(最大)二叉堆。从下到上，从左到右遍历父节点调整
for (i = n / 2 - 1; i >= 0; i--)
maxheap_down(a, i, n-1);
// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素
for (i = n - 1; i > 0; i--)
{
// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最大的。
swap(a[0], a[i]);
// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最大堆。
// 即，保证a[i-1]是a[0...i-1]中的最大值。//下面一条语句start=0是因为第一个父节点改变了值，要重新调整为最大堆
maxheap_down(a, 0, i-1);
}
}
/ brief /
void makeheap_down(vector<int>&array, int start, int end){
int c = start;//c是当前要下滤的节点
for (int i = 2 * start + 1; i <= end; c = i, i = 2 * i + 1){
if (i<end&&array[i] < array[i + 1])i++;//i<end不能漏，不然i=end;i+1超出范围
if (array[c] >= array[i])break;
else{
swap(array[c], array[i]);
}
}
}
/*堆排序*/
void maxheap_sort(vector<int>&a, int n){
//第一个for循环构建最大堆，n为向量长度
for (int i = n / 2 - 1; i >= 0; i--)
makeheap_down(a, i, n-1);
//第二个for循环用来排序
for (int i = n-1; i>0; i--){
swap(a[0], a[i]);
makeheap_down(a, 0, i-1);//再次调整为最大堆 ，i不能=0
}
}
4.选择排序
void select_sort(vector<int>&a){
for (int i = 0; i < a.size()-1; i++){
int min_index = i;
for (int j = i+1; j < a.size(); j++){
if (a[j] < a[min_index]){
min_index = j;
}
}
if (min_index!=i)swap(a[i], a[min_index]);
}
}
5.冒泡排序
void bubble_sort(vector<int>&a){
for (int i = 0; i < a.size()-1; i++){
for (int j = 0; j < a.size()-1-i; j++){
if (a[j] > a[j + 1]){
//swap(a[j], a[j + 1]);
int tmp = a[j];
a[j] = a[j + 1];
a[j + 1] = tmp;
}
}
}
}
6.插入排序
void insert_sort(vector<int>&a){
for (int i = 1; i < a.size(); i++){
int j = i;
while (j>0 && a[j] < a[j - 1]){
swap(a[j], a[j - 1]);
j--;
}
}
}
7.桶排序和基数排序
void bucketSort(vector<int>&input,int max){
vector<int>bucket(max, 0);//max是要排序数组中的最大值+1
for (int i = 0; i < input.size(); i++){
bucket[input[i]]++;
}
for (int i = 0,j=0; i < max; i++){
while ((bucket[i]--)> 0){//可以排序重复数字
input[j++] = i;
}
}
}
基数排序补充：基数排序(Radix Sort)是桶排序的扩展，它的基本思想是：将整数按位数切割成不同的数字，然后按每个位数分别比较。
具体做法是：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
/*
* 获取数组a中最大值
*
* 参数说明：
* a -- 数组
* n -- 数组长度
*/
int get_max(int a[], int n)
{
int i, max;
max = a[0];
for (i = 1; i < n; i++)
if (a[i] > max)
max = a[i];
return max;
}
/*
* 对数组按照"某个位数"进行排序(桶排序)
*
* 参数说明：
* a -- 数组
* n -- 数组长度
* exp -- 指数。对数组a按照该指数进行排序。
*
* 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
* (01) 当exp=1表示按照"个位"对数组a进行排序
* (02) 当exp=10表示按照"十位"对数组a进行排序
* (03) 当exp=100表示按照"百位"对数组a进行排序
* ...
*/
void count_sort(int a[], int n, int exp)
{
int output[n]; // 存储"被排序数据"的临时数组
int i, buckets[10] = {0};
// 将数据出现的次数存储在buckets[]中
for (i = 0; i < n; i++)
buckets[ (a[i]/exp)%10 ]++;
// 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
for (i = 1; i < 10; i++)
buckets[i] += buckets[i - 1];
// 将数据存储到临时数组output[]中
for (i = n - 1; i >= 0; i--)
{
output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
buckets[ (a[i]/exp)%10 ]--;
}
// 将排序好的数据赋值给a[]
for (i = 0; i < n; i++)
a[i] = output[i];
}
/*
* 基数排序
*
* 参数说明：
* a -- 数组
* n -- 数组长度
*/
void radix_sort(int a[], int n)
{
int exp; // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
int max = get_max(a, n); // 数组a中的最大值
// 从个位开始，对数组a按"指数"进行排序
for (exp = 1; max/exp > 0; exp *= 10)
count_sort(a, n, exp);
}
#include <stdio.h> #include <algorithm> #include <map> #include <iostream> #include <vector> using namespace std; //自己写的实现 /* * 快速排序 * 平均时间复杂度O(nlogn)：对应的情况是每次递归结束后，(i-left)约等于(right-i)，两边的数的数量相同，类似二分，所以递归深度logn，总复杂度O(nlogn) * 最坏时间复杂度O(n*n)：对应的情况是每次递归结束后，i等于left或者i等于right，每层递归只能排序一个数，这样的话递归深度就是n，总复杂度O(n*n)，对已经排序好的数组再次排序就是这种情况 * 为什么要右边的哨兵先行： 如果选取最左边的数nums[left]作为基准数，那么先从右边开始可保证i,j在相遇时，相遇数是小于基准数的，交换之后base所在位置的左边都小于base。但先从左边开始,相遇数是大于基准数的，无法满足base左边的数都小于它。所以进行扫描，要从基准数的对面开始 * 稳定性：快速排序是不稳定排序，它可能会交换两个值相同的元素。比如序列为 5 3 3 4 3 8 9 10 11，现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱，所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j]交换的时刻。 */ class QuickSort { public: void quickSort(vector<int>& nums, int left,int right) { if(left >= right) return; int i=left, j=right; int base = nums[left]; while(i < j) { while(nums[j]>=base && i<j) j--; while(nums[i]<=base && i<j) i++; if(i < j) { swap(nums[i], nums[j]); } } swap(nums[i], nums[left]); quickSort(nums, left,i-1); quickSort(nums, i+1,right); } vector<int> sortArray(vector<int>& nums) { quickSort(nums, 0, nums.size()-1); return nums; } }; /* * 归并排序 * 平均时间复杂度和最坏时间复杂度都是O(nlogn) * 稳定性：稳定排序 * 缺点：需要辅助数组 */ class MergeSort { public: void merge(vector<int>& nums, int left, int right, int mid) { vector<int> temp(right-left+1); int i = left, j = mid+1, t = 0; while (i<=mid && j<=right){ if (nums[i] <= nums[j]) temp[t++] = nums[i++]; else temp[t++] = nums[j++]; } while (i <= mid){ temp[t++] = nums[i++]; } while (j <= right){ temp[t++] = nums[j++]; } t = 0; while (left <= right){ nums[left++] = temp[t++]; } } void mergeSort(vector<int>& nums, int left, int right){ if (left < right){ int mid = (left + right) / 2; mergeSort(nums, left, mid); mergeSort(nums, mid + 1, right); merge(nums, left, right, mid); } } vector<int> sortArray(vector<int>& nums) { mergeSort(nums, 0, nums.size()-1); return nums; } }; /* * 堆排序 * 稳定性：不稳定 */ class Heap { private: int heap[10005]; int size = 0; public: int getSize() { return size; } void siftDown(int i) { while(true) { int t = i; if(i*2 <= size) { if(heap[i*2] < heap[i]) t = i*2; } if(i*2+1 <= size) { if(heap[i*2+1] < heap[t]) t = i*2+1; } if(t != i) { swap(heap[t], heap[i]); i = t; } else { break; } } } void siftUp(int i) { while (true) { if (i == 1) break; if (heap[i/2] > heap[i]) { swap(heap[i/2], heap[i]); i /= 2; } else { break; } } } void pop () { heap[1] = heap[size--]; siftDown(1); } void add (int num) { heap[++size] = num; siftUp(size); } int top() { return heap[1]; } }; class HeapSort { public: int findKthLargest(vector<int>& nums, int k) { Heap hp; for(auto x: nums) { hp.add(x); if (hp.getSize() > k) hp.pop(); } return hp.top(); } }; int main() { Solution s; vector<int> v; for(int i=1; i<=50000; ++i) v.push_back(i); cout<<1<<endl; vector<int> nums = s.sortArray(v); // for(int i=0; i<nums.size(); ++i) // cout<<nums[i]<<endl; }
