数据结构：排序
整数数组排序，正序和反序
参考：十大经典排序算法
排序算法是《数据结构与算法》中最基本的算法之一。
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：
名词解释：
- n：数据规模
- k："桶"的个数
- In-place：占用常数内存，不占用额外内存
- Out-place：占用额外内存
- 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同
冒泡排序
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
算法思想
假设排序表为L【1....n】，第 i 趟排序即从L【i....n】中选择关键字最小的元素与L(i)交换，每一趟排序可以确定一个元素的最终位置，这样经过n - 1 趟排序就可以使得整个排序表有序·
算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
动图演示
C代码
#include <stdio.h>
void bubble_sort(int p,int arr[], int len)
{
int i, j, temp;
//执行len-1次，最后第len次，就剩一个值，所以不用执行
if(p == 0)
{//降序
for (i = 0; i < len - 1; i++)
{
//每次len-1-i趟，确定每趟中的最大值
for (j = 0; j < len - 1 - i; j++)
{
if (arr[j] < arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}else
{
for (i = 0; i < len - 1; i++)
{
//每次len-1-i趟，确定每趟中的最大值
for (j = 0; j < len - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}
int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = (int) sizeof(arr) / sizeof(*arr);
bubble_sort(0,arr, len);
int i;
for (i = 0; i < len; i++)
{
printf("%d ", arr[i]);
}
system("pause");
return 0;
}
优化
优化算法，就是立一个 flag，当下一趟序列遍历中元素没有发生交换，则证明该序列已经有序。
C代码
#include <stdio.h>
void bubble_sort(int p,int num[], int len)
{//冒泡排序
int flag,temp;
if(p==0)
{//降序
for(int i = 1;i < len ;i++)
{
flag = 0;//默认为0，表示没有发生交换
for(int j = 0;j < len - i;j++) // 从前向后比较
{
if(num[j] < num[j + 1])
{
temp = num[j];
num[j] = num[j + 1];
num[j + 1] = temp;
flag = 1;//修改为1，表示发生交换
}
}
//若没发生交换，则证明该序列已经有序
if(flag = 0)
{
break;
}
}
}else
{//升序
for(int i = 1;i < len ;i++)
{
flag = 0;//默认为0，表示没有发生交换
for(int j = 0;j < len - i;j++) // 从前向后比较
{
if(num[j] > num[j + 1])
{
temp = num[j];
num[j] = num[j + 1];
num[j + 1] = temp;
flag = 1;//修改为1，表示发生交换
}
}
//若没发生交换，则证明该序列已经有序
if(flag = 0)
{
break;
}
}
}
}
int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = (int) sizeof(arr) / sizeof(*arr);
bubble_sort(1,arr, len);
int i;
for (i = 0; i < len; i++)
{
printf("%d ", arr[i]);
}
system("pause");
return 0;
}
选择排序
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。
算法思想
算法步骤
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
动图演示
C代码
#include <stdio.h>
void swap(int *a,int *b) //交换两个数
{
int temp = *a;
*a = *b;
*b = temp;
}
void selection_sort(int p,int num[], int len)
{//选择排序
int min_max;
int i=0,j=0;
if(p == 0)
{//反序
for(i=0;i<len-1;i++)
{
min_max=i;
for(j=i+1;j<len;j++)
{
if(num[j]>num[min_max])
{
min_max=j;
}
}
if(min_max != i)
{
swap(&num[i],&num[min_max]);
}
}
}else
{//正序
for(i=0;i<len-1;i++)
{
min_max=i;
for(j=i+1;j<len;j++)
{
if(num[j]<num[min_max])
{
min_max=j;
}
}
if(min_max != i)
{
swap(&num[i],&num[min_max]);
}
}
}
}
int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = (int) sizeof(arr) / sizeof(*arr);
selection_sort(0,arr, len);
int i;
for (i = 0; i < len; i++)
{
printf("%d ", arr[i]);
}
system("pause");
return 0;
}
插入排序
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。
算法思想
算法步骤
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
动图演示
C代码
#include <stdio.h>
#include <stdlib.h>
void insertion_sort(int p,int arr[], int len)
{
int i,j,key;
for (i=1;i<len;i++)
{//从前向后扫描
key = arr[i];
j=i-1;
if(p==0)
{//降序
while((j>=0) && (arr[j]<key))
{
arr[j+1] = arr[j];
j--;
}
}else
{//升序
while((j>=0) && (arr[j]>key))
{
arr[j+1] = arr[j];
j--;
}
}
arr[j+1] = key;
}
}
void main()
{
int a[] = {1,4,7,8,5,2,3};
int len=sizeof(a)/sizeof(int);
insertion_sort(1,a,len);
printf("排序后：\n");
for(int i = 0;i < len;i++)
{
printf("%d ",a[i]);
}
system("pause");
}
希尔排序
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
- 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；
- 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。
算法思想
算法步骤
我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。
3 9 1 7 2 8 5 4 6 0
3 9 1 7 2 8 5 4 6 0
3 5 1 6 2 8 9 4 7 0
3 5 1 6 0 8 9 4 7 2
3 5 1 6 0 8 9 4 7 2
0 5 1 6 3 8 7 4 9 2
0 2 1 4 3 5 7 6 9 8
gap=2：
0 2 1 4 3 5 7 6 9 8
0 1 2 3 4 5 6 7 8 9
动图演示
C代码
#include <stdio.h>
#include <stdlib.h>
void shell_sort(int p,int arr[], int len)
{
int gap, i, j;
int temp;
for (gap = len >> 1; gap > 0; gap >>= 1)//gap = len >> 1 相当于gap = len/2
for (i = gap; i < len; i++)
{//小序列内调整
temp = arr[i];
if(p == 0)
{//降序
for (j = i - gap; j >= 0 && arr[j] < temp; j -= gap)
arr[j + gap] = arr[j];
}else
{//升序
for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
arr[j + gap] = arr[j];
}
arr[j + gap] = temp;
}
}
void main()
{
int a[] = {8,9,1,7,2,3,5,4,6,0};
int len=sizeof(a)/sizeof(int);
shell_sort(1,a,len);
printf("排序后：\n");
for(int i = 0;i < len;i++)
{
printf("%d ",a[i]);
}
system("pause");
}
归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
算法思想
算法步骤
-
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
-
设定两个指针，最初位置分别为两个已经排序序列的起始位置；
-
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
-
重复步骤 3 直到某一指针达到序列尾；
-
将另一序列剩下的所有元素直接复制到合并序列尾。
用图来表示：
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
动图演示
C代码
（1）递归：
#include <stdio.h>
#include <stdlib.h>
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
if (start >= end)
return;
//分段（分）
int len = end - start, mid = (len >> 1) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge_sort_recursive(arr, reg, start1, end1);
merge_sort_recursive(arr, reg, start2, end2);
int k = start;
//比较
while (start1 <= end1 && start2 <= end2)
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
while (start1 <= end1)
reg[k++] = arr[start1++];
while (start2 <= end2)
reg[k++] = arr[start2++];
//链接（治）
for (k = start; k <= end; k++)
arr[k] = reg[k];
}
void merge_sort(int arr[], const int len) {
int reg[len];//申请空间
merge_sort_recursive(arr, reg, 0, len - 1);
}
void main()
{
int a[] = {8,4,5,7,1,3,6,2};
int len=sizeof(a)/sizeof(int);
merge_sort(a,len);
printf("排序后：\n");
for(int i = 0;i < len;i++)
{
printf("%d ",a[i]);
}
system("pause");
}
（2）迭代：
#include <stdio.h>
#include <stdlib.h>
int min(int x, int y) {
return x < y ? x : y;
}
void merge_sort(int arr[], int len) {
int *a = arr;
int *b = (int *) malloc(len * sizeof(int));//申请空间
int seg, start;
for (seg = 1; seg < len; seg += seg) {
for (start = 0; start < len; start += seg * 2) {
int low = start, mid = min(start + seg, len), high = min(start + seg * 2, len);
int k = low;
int start1 = low, end1 = mid;
int start2 = mid, end2 = high;
while (start1 < end1 && start2 < end2)
b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
while (start1 < end1)
b[k++] = a[start1++];
while (start2 < end2)
b[k++] = a[start2++];
}
int *temp = a;
a = b;
b = temp;
}
if (a != arr) {
int i;
for (i = 0; i < len; i++)
b[i] = a[i];
b = a;
}
free(b);
}
void main()
{
int a[] = {8,4,5,7,1,3,6,2};
int len=sizeof(a)/sizeof(int);
merge_sort(a,len);
printf("排序后：\n");
for(int i = 0;i < len;i++)
{
printf("%d ",a[i]);
}
system("pause");
}
快速排序
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。
快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。
快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：
快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序
算法思想
算法步骤
-
从数列中挑出一个元素，称为 "基准"（pivot）;
-
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
-
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
动图演示
C代码
（1）非递归：
#include <stdio.h>
#include <stdlib.h>
typedef struct _Range {
int start, end;
} Range;
Range new_Range(int s, int e) {
Range r;
r.start = s;
r.end = e;
return r;
}
void swap(int *x, int *y) {
int t = *x;
*x = *y;
*y = t;
}
void quick_sort(int arr[], const int len) {
if (len <= 0)
return; //
// r[]模拟列表,p为数量,r[p++]为push,r[--p]为pop且取得元素
Range r[len];
int p = 0;
r[p++] = new_Range(0, len - 1);
while (p) {
Range range = r[--p];
if (range.start >= range.end)
continue;
int mid = arr[(range.start + range.end) / 2]; // 选取中间点为基准点
int left = range.start, right = range.end;
do {
while (arr[left] < mid) ++left; // 检测基准点左侧是否符合要求
while (arr[right] > mid) --right; //检测基准点右侧是否符合要求
if (left <= right) {
swap(&arr[left], &arr[right]);
left++;
right--; // 移动指针以改变
}
} while (left <= right);
if (range.start < right) r[p++] = new_Range(range.start, right);
if (range.end > left) r[p++] = new_Range(left, range.end);
}
}
void main()
{
int a[] = {1,4,7,8,5,2,3};
int len=sizeof(a)/sizeof(int);
quick_sort(a,len);
printf("排序后：\n");
for(int i = 0;i < len;i++)
{
printf("%d ",a[i]);
}
system("pause");
}
（2）递归：
#include <stdio.h>
#include <stdlib.h>
//链表划分【当前第一个元素设为pivot】
int partition(int p,int a[],int low,int high)
{
int pivot = a[low]; //当前第一个元素设为pivot，对表进行划分
while(low < high)
{
if(p==0)
{//降序
//将比pivot小的元素移动到左侧
while(low < high && a[high] <= pivot)
high--;//找到比pivot小的值
a[low] = a[high];//移动
//将比pivot大的元素移动到右侧
while(low < high && a[low] >= pivot)
low++;
a[high] = a[low];
}else
{//升序
//将比pivot小的元素移动到左侧
while(low < high && a[high] >= pivot)
high--;//找到比pivot小的值
a[low] = a[high];//移动
//将比pivot大的元素移动到右侧
while(low < high && a[low] <= pivot)
low++;
a[high] = a[low];
}
}
a[low] = pivot; //pivot元素存放到最终位置
return low; //返回存放pivot的最终位置
}
//快速排序递归式
void quicksort(int p,int a[],int low,int high)
{
if(low < high)
{
int pivotpos = partition(p,a,low,high);
quicksort(p,a,low,pivotpos - 1);
quicksort(p,a,pivotpos+1,high);
}
}
void main()
{
int a[] = {1,4,7,8,5,2,3};
int low = 0, high = n - 1;
quicksort(1,a,low,high);
printf("排序后：\n");
for(int i = 0;i < n;i++)
{
printf("%d ",a[i]);
}
system("pause");
}
堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：
- 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
- 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
堆排序的平均时间复杂度为 Ο(nlogn)。
算法思想
算法步骤
-
创建一个堆 H[0……n-1]；
-
把堆首（最大值）和堆尾互换；
-
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
-
重复步骤 2，直到堆的尺寸为 1。
动图演示
C代码
#include <stdio.h>
#include <stdlib.h>
void swap(int *a, int *b) {
int temp = *b;
*b = *a;
*a = temp;
}
void max_heapify(int arr[], int start, int end) {
// 建立父节点指标和子节点指标
int dad = start;
int son = dad * 2 + 1;
while (son <= end) { // 若子节点指标在范围内才做比较
if (son + 1 <= end && arr[son] < arr[son + 1]) // 先比较两个子节点大小，选择最大的
son++;
if (arr[dad] > arr[son]) //如果父节点大于子节点代表调整完毕，直接跳出函数
return;
else { // 否则交换父子内容再继续子节点和孙节点比较
swap(&arr[dad], &arr[son]);
dad = son;
son = dad * 2 + 1;
}
}
}
void heap_sort(int arr[], int len) {
int i;
// 初始化，i从最后一个父节点开始调整
for (i = len / 2 - 1; i >= 0; i--)
max_heapify(arr, i, len - 1);
// 先将第一个元素和已排好元素前一位做交换，再重新调整，直到排序完毕
for (i = len - 1; i > 0; i--) {
swap(&arr[0], &arr[i]);
max_heapify(arr, 0, i - 1);
}
}
int main() {
int arr[] = { 3, 5, 3, 0, 8, 6, 1, 5, 8, 6, 2, 4, 9, 4, 7, 0, 1, 8, 9, 7, 3, 1, 2, 5, 9, 7, 4, 0, 2, 6 };
int len = (int) sizeof(arr) / sizeof(*arr);
heap_sort(arr, len);
int i;
for (i = 0; i < len; i++)
printf("%d ", arr[i]);
printf("\n");
system("pause");
return 0;
}
计数排序
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
1. 计数排序的特征
当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。
由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。
通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。
算法思想
算法步骤
（1）找出待排序的数组中最大和最小的元素
（2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项
（3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
（4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
动图演示
C代码
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//打印函数
void print_arr(int *arr, int n) {
int i;
printf("%d", arr[0]);
for (i = 1; i < n; i++)
printf(" %d", arr[i]);
printf("\n");
}
void counting_sort(int *ini_arr, int *sorted_arr, int n) {
int *count_arr = (int *) malloc(sizeof(int) * 100);
int i, j, k;
for (k = 0; k < 100; k++)
count_arr[k] = 0;
for (i = 0; i < n; i++)
count_arr[ini_arr[i]]++;
for (k = 1; k < 100; k++)
count_arr[k] += count_arr[k - 1];
for (j = n; j > 0; j--)
sorted_arr[--count_arr[ini_arr[j - 1]]] = ini_arr[j - 1];
free(count_arr);
}
int main(int argc, char **argv) {
int n = 10;
int i;
int *arr = (int *) malloc(sizeof(int) * n);
int *sorted_arr = (int *) malloc(sizeof(int) * n);
//随机生成输入
srand(time(0));
for (i = 0; i < n; i++)
arr[i] = rand() % 100;
//打印输出
printf("ini_array: ");
print_arr(arr, n);
//计数排序
counting_sort(arr, sorted_arr, n);
//排序后输出
printf("sorted_array: ");
print_arr(sorted_arr, n);
free(arr);
free(sorted_arr);
system("pause");
return 0;
}
桶排序
基数排序
