史上最全排序算法整理（2）

本篇文章我们将接着上篇继续介绍常见的排序算法，有需要的小伙伴可以移步史上最全排序算法整理（1）查看相关内容哦

1.冒泡排序

1.1基本思想

在待排序的一组数中，将相邻的两个数进行比较，若前面的数比后面的数大就交换两数，否则不交换；如此下去，直至最终完成排序。在排序过程中，大的数据往下沉，小的数据往上浮，就像气泡一样，于是将这种排序算法形象地称为冒泡排序。

1.2特性总结

时间复杂度：O（N^2）
空间复杂度：O（1）
稳定性：稳定

1.3代码实现

void BubbleSort(int* a, int n) 
{for (int j = 0; j < n - 1; j++){int exchange = 0;for (int i = 1; i < n - j; i++){if (a[i - 1] > a[i]){Swap(&a[i - 1], &a[i]);exchange = 1;}}if (exchange == 0)break;}
}

2.快速排序

2.1基本思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法。

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中的所有元素均大于基准值，然后对左右子序列重复该过程，直到所有元素都排列在相应的位置上为止。

2.2优化方法

选择key时采用三数取中法

递归到小子区间的时候，考虑使用插入排序

2.3特性总结

时间复杂度：O（N*logN）
空间复杂度：O（logN）
稳定性：不稳定。其元素比较和交换是跳跃进行的，因此它是一种不稳定的排序算法。

2.4代码实现

//快排三数取中
int GetMidi(int* a, int left, int right)
{int mid = (left + right) / 2;if (a[left] < a[mid]){if (a[mid] < a[right]){return mid;}else if (a[left] > a[right]){return left;}else{return right;}}else//a[left]>=a[mid]{if (a[mid] > a[right]){return mid;}else if (a[left] < a[right]){return left;}else{return right;}}
}//Hoare
void QuickSort1(int* a, int left, int right) 
{//区间只有一个值或者不存在的就是最小子问题if (left >= right)return;//小区间选择走插入，可以减少90%左右的递归if (right - left + 1 < 10){InsertSort(a + left, right - left + 1);}else{int begin = left, end = right;int midi = Getmidi(a, left, right);Swap(&a[left], &a[midi]);int keyi = left;while (left < right){//right先走找小while (left < right && a[right] >= a[keyi]){right--;}while (left < right && a[left] <= a[keyi]){left++;}Swap(&a[left], &a[right]);}Swap(&a[left], &a[keyi]);keyi = left;QuickSort1(a, begin, keyi - 1);QuickSort1(a, keyi + 1, end);}
}//快速排序-前后指针
void QuickSort2(int* a, int left, int right) 
{if (left >= right)return;int keyi = left;int prev = left;int cur = left + 1;while (cur <= right){if (a[cur] < a[keyi] && ++prev != cur){Swap(&a[prev], &a[cur]);}++cur;}Swap(&a[keyi], &a[prev]);keyi = prev;QuickSort2(a, left, keyi - 1);QuickSort2(a, keyi+1, right);
}

3.归并排序

3.1基本思想

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的典型应用。将已有序的子序列合并，得到完全有序的序列

即先使每个子序列有序，再使子序列段间有序，若将两个有序表合并成一个有序表，称为二路归并。

3.2特性总结

时间复杂度O（N*logN）
空间复杂度O（N）
稳定性：稳定

3.3代码实现

void _MergeSort(int* a, int begin, int end, int* tmp)
{if (begin == end)return;int mid = (begin + end) / 2;_MergeSort(a, begin, mid, tmp);_MergeSort(a, mid + 1, end, tmp);int begin1 = begin, end1 = mid;int begin2 = mid + 1,end2 = mid;int i = begin;//依次比较，取较小的尾插while (begin1 <= end1 && begin2 <= end2){if (a[begin1] <= a[begin2]){tmp[i++] = a[begin1++];}else{tmp[i++] = a[begin2++];}}while (begin1 <= end1){tmp[i++] = a[begin1++];}while (begin2 <= end1){tmp[i++] = a[begin2++];}memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}
//归并
void MergeSort(int* a, int n) 
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}_MergeSort(a, 0, n - 1, tmp);free(tmp);tmp = NULL;
}

3.4归并排序的非递归

相比于递归算法，归并排序的非递归算法不用多次调用同一个函数，不会向递归算法一样因为函数嵌套调用次数太多而造成栈溢出。相比于递归的算法，非递归与之不同点就一个：在递归中我们通过递归到最底层（即两个数一组）进行排序，而非递归则是直接把数组分成两个数一组进行排序，这边排序完之后，再把数组分成四个一组排序，直到整个数组被分成两组，排序后就结束。

void MergeSortNonR(int* a, int n) 
{int* tmp = (int*)malloc(sizeof(int) * n);if (tmp == NULL){perror("malloc fail");return;}int gap = 1;while (gap < n){for (int j = 0; j < n; j += 2 * gap){int begin1 = j, end1 = begin1 + gap - 1;int begin2 = begin1 + gap, end2 = begin2 + gap - 1;//越界处理if (end1 >= n || begin2 >= n)break;if (end2 >= n)end2 = n - 1;int i = j;while (begin1 <= end1 && begin2 <= end2){if (a[begin1] <= a[begin2]){tmp[i++] = a[begin1++];}else{tmp[i++] = a[begin2++];}}while (begin1 <= end1){tmp[i++] = a[begin1++];}while (begin2 <= end1){tmp[i++] = a[begin2++];}memcpy(a + j, tmp + j, sizeof(int) * (end2 - j + 1));}gap *= 2;}free(tmp);tmp = NULL;
}

4.非比较排序之计数排序

前面我们介绍的排序都是通过比较实现的，下面我们来看看一个常见的非比较排序

4.1基本思想

遍历原数组，统计相同元素出现的个数，一个值出现了几次，映射的位置次数就被增加几，然后根据统计的结果将序列回收到原来的序列中。

4.2特性总结

计数排序在数据范围集中地时候，效率很高，但是适用的范围很有限
时间复杂度：O（MAX（N，范围））
空间复杂度：O（范围）
稳定性：稳定

4.3代码实现

void CountSort(int* a, int n)
{int min = a[0], max = a[0];for (int i = 1; i < n; i++){if (a[i] > max)max = a[i];if (a[i] < min)min = a[i];}int range = max - min + 1;//先根据最大值和最小值求出范围int* count = (int*)malloc(sizeof(int) * range);if (count == NULL){perror("malloc fail");return;}memeset(count, 0, sizeof(int) * range);for (int i = 0; i < n; i++){count[a[i] - min]++;}int j = 0;for (int i = 0; i < range; i++){while (count[i]--){a[j++] = i + min;}}
}