原理部分:十大经典排序算法(动图演示)
比起参考文献,本文的不同之处在于代码都为C语言编写。
算法复杂度
排序方法 | 时间复杂度 (av) | 时间复杂度 (best) | 时间复杂度 (worst) | 空间复杂度 | 稳定性 |
---|---|---|---|---|---|
冒泡排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 |
快速排序 | O(nlog2n) | O(nlog2n) | O(n2) | O(nlog2n) | 不稳定 |
插入排序 | O(n2) | O(n) | O(n2) | O(1) | 稳定 |
希尔排序 | O(n1.3) | O(n) | O(n2) | O(1) | 不稳定 |
选择排序 | O(n2) | O(n2) | O(n2) | O(1) | 不稳定 |
堆排序 | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(1) | 不稳定 |
归并排序 | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(n) | 稳定 |
- 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面。
- 不稳定:如果a原本在b的前面,而a=b,排序之后 a 可能会出现在 b 的后面。
冒泡排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
算法描述
- 比较相邻的元素。如果第一个比第二个大,就交换它们两个;
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
- 针对所有的元素重复以上的步骤,除了最后一个;
- 重复步骤1~3,直到排序完成。
代码实现
void swap(int *a, int *b) {
int c = *a;
*a = *b;
*b = c;
}
void Bubble_Sort(int a[], int size_a) {
int i, j;
for (i = size_a - 1; i > 0; i--)
for (j = 0; j < i; j++)
if(a[j] > a[j + 1]) swap(&a[j], &a[j + 1]);
}
快速排序
快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
核心思想:在每一个关键字的设置后,关键字的位置就会被确定(正确位置)。
做法:在一个递归循环中,若寻找到比edge小(大)的数i,整个edge到 i - 1 往后推一位,并且 i 加入到原edge位置。
算法描述
- 从数列中挑出一个元素,称为 “基准”(pivot);
- 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
- 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
代码实现
#include<stdio.h>
#include<string.h>
void swap(char *a, char *b) {
char c = *a;
*a = *b;
*b = c;
}
int Quick_Sort(char a[], int _lift, int _right) {
if (_lift >= _right)
return 0;
int edge = _lift, i = _lift, swap_value, j;
for (; i <= _right; i++) {
if (a[i] < a[edge]) {
for (j = i; j > edge; j--) { //小于edge的数添加到edge前边
swap(&a[j], &a[j - 1]);
}
edge++; //参数设置
}
}
int size_a = strlen(a);
Quick_Sort(a, 0, edge - 1);
Quick_Sort(a, edge + 1, _right);
return 0;
}
插入排序
插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
算法描述
- 从第一个元素开始,该元素可以认为已经被排序;
- 取出下一个元素,在已经排序的元素序列中从后向前扫描;
- 如果该元素(已排序)大于新元素,将该元素移到下一位置;
- 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
- 将新元素插入到该位置后边;
- 重复步骤2~5。
代码实现
int Selection_Sort(char a[], int size) {
int max,max_j;
for (int i = 0; i < size; i++) {
max = a[i];
max_j = i;
for (int j = i + 1; j < size; j++) {
if (max < a[j]) {
max = a[j];
max_j = j;
}
}
if (i != max_j)
swap(&a[max_j], &a[i]);
}
return 0;
}
希尔排序
它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
简单来说将插入排序集分成很多块,分别进行插入排序
算法描述
- 选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
- 按增量序列个数k,对序列进行k 趟排序;
- 每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。
代码实现
void shell_Sort(char a[], int len){
int i, j, k, gap; // gap 为步长
char tmp;
for (gap = len / 2; gap > 0; gap /= 2) { // 步长初始化为数组长度的一半,每次遍历后步长减半,
for (i = 0; i < gap; ++i) { // 变量 i 为每次分组的第一个元素下标
for (j = i + gap; j < len; j += gap) { //对步长为gap的元素进行直插排序,当gap为1时,就是直插排序
tmp = a[j]; // 备份a[i]的值
k = j - gap; // j初始化为i的前一个元素(与i相差gap长度)
while (k >= 0 && a[k] > tmp) {
a[k + gap] = a[k]; // 将在a[i]前且比tmp的值大的元素向后移动一位
k -= gap;
}
a[k + gap] = tmp;
}
}
}
}
选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下:
- 初始状态:无序区为R[1…n],有序区为空;
- 第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1…i-1]和R(i…n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
- n-1趟结束,数组有序化了。
代码实现
void swap(char *a, char *b) {
char c = *a;
*a = *b;
*b = c;
}
int Selection_Sort(char a[], int size) {
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
if (a[i] < a[j])
swap(&a[i], &a[j]);
}
}
return 0;
}
堆排序
堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。
算法描述
- 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆,此堆为初始的无序区;
- 将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n];
- 由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。
代码实现
int Heap_Sort_fun(char a[], int i, int size) { //堆排序
int _lift = 2 * i + 1, // lift kid
_right = 2 * i + 2; // right kid
if (_lift >= size) // lift overload
return 0;
Heap_Sort_fun(a, _lift, size);
Heap_Sort_fun(a, _right, size);
if (a[i] > a[_lift])
swap(&a[i], &a[_lift]);
if (_right < size) // right overload
if (a[i] > a[_right])
swap(&a[i], &a[_right]);
return 0;
}
void Heap_Sort(char a[]) {
for (int i = strlen(a); i > 0; i--) {
Heap_Sort_fun(a, 0, i);
swap(&a[0], &a[i - 1]);
}
}
归并排序
归并排序(Merge Sort)是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。
算法描述
- 把长度为n的输入序列分成两个长度为n/2的子序列;
- 对这两个子序列分别采用归并排序;
- 将两个排序好的子序列合并成一个最终的排序序列。
代码实现
1、递归方法(不建议)
简单粗暴
- 使用递归的方法来分元素
- 使用临时数组来保存排好序的元素
- 把临时数组中的元素拷贝给原数组
int Merge_Sort(char a[]);
int Merge_Sort_fun(char a[], int lift_, int mid_, int right_);
void swap(char *a, char *b);
void swap(char *a, char *b) {
int c = *a;
*a = *b;
*b = c;
}
int Merge_Sort(char a[]){
int size_a = strlen(a);
Merge_Sort_fun(a, 0, size_a / 2, size_a - 1);
return 0;
}
int Merge_Sort_fun(char a[], int lift_, int mid_, int right_) {
if (right_ - lift_ == 1) {
if (a[right_] > a[lift_])
swap(&a[right_], &a[lift_]);
return 1;
}
if (right_ > lift_) {
char total[10]; // set max
int l_s = mid_-lift_, r_s = right_ - mid_ + 1;
Merge_Sort_fun(a, lift_, (lift_ + mid_) / 2, mid_ - 1);
Merge_Sort_fun(a, mid_, (right_ + mid_) / 2, right_);
int i = lift_, j = mid_, k = lift_;
while (i < mid_&& j <= right_ ) {
if (a[i] > a[j])
total[k++] = a[i++];
else
total[k++] = a[j++];
}
while (i < mid_)
total[k++] = a[i++];
while (j <= right_)
total[k++] = a[j++];
for (int k = lift_; k <= right_; k++)
a[k] = total[k];
}
return 0;
}
2、非递归方法 (建议)
- 外循环为“治”排序的字数组size:从2开始自乘2,直到超过最大数组长度len,将size取值为len作为最后一次循环;
- 内循环为“分”排序,通过字数组size改变起始、中间、末端数组大小,直到末端超过数组长度len,将right取值为len作为最后一次循环。
int Merge_Sort(char a[]) {
int len = strlen(a), group_length = 1;
int lift_, right_, mid_, i, j, k;
int total[10];
do {
group_length *= 2;
lift_ = 0;
mid_ = 0 + group_length / 2;
if (group_length > len) // 超出处理 (mid_不能跟着变)
group_length = len;
right_ = group_length - 1;
do {
i = lift_;
j = mid_;
k = lift_;
while (i < mid_&& j <= right_) {
if (a[i] > a[j])
total[k++] = a[i++];
else
total[k++] = a[j++];
}
while (i < mid_)
total[k++] = a[i++];
while (j <= right_)
total[k++] = a[j++];
for (k = lift_; k <= right_; k++)
a[k] = total[k];
lift_ += group_length;
mid_ += group_length;
right_ += group_length;
if (right_ >= len) { // 超出处理
right_ = len - 1;
if (right_ < mid_)
lift_ += group_length;
}
} while (lift_ < len);
} while (group_length < len);
return 0;
}