此次来记录一下各种排序算法的基本模板：
排序：所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
选择排序：
- 每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
- 元素集合array[i]--array[n-1]中选择关键码最大(小)的数据元素。
- 若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换。
- 在剩余的array[i]--array[n-2]（array[i+1]--array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素。
void SelectSort(int* a, int n)
{
int begin = 0, end = n - 1;
while (begin < end)
{
int maxi = begin, mini = begin;
for (int i = begin; i <= end; i++)
{
if (a[i] > a[maxi])
{
maxi = i;
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[begin], &a[mini]);
// 如果maxi和begin重叠，修正一下即可
if (begin == maxi)
{
maxi = mini;
}
Swap(&a[end], &a[maxi]);
++begin;
--end;
}
}直接选择排序的特性总结：
1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
插入排序
直接插入排序是一种简单的插入排序法，其基本思想是：
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
当插入第i(i>=1)个元素时，前面的array[0],array[1],…,array[i-1]已经排好序，此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较，找到插入位置即将array[i]插入，原来位置上的元素顺序后移。
//直接插入排序
void Insertsort(int* a, int n)
{
for (int i = 1; i < n; i++)
{
//默认[0,end]有序，插入tmp仍然有序
//刚开始[0,0]有序，从第二个（i = 1）个数据开始插入，也就是a[i]进行插入
int tmp = a[i];
int end = i - 1;
while (end >= 0)
{
//依次进行比较
if (a[end] > tmp)
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
//将要插入的数据进行插入
a[end + 1] = tmp;
}
}直接插入排序的特性总结：
1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定
堆排序
堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是
通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。
#include<stdio.h>
void Swap(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void Adjustdown(int* a, int n, int parent)
{
//建立小堆
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && a[child] > a[child + 1])
{
++child;
}
if (a[parent] > a[child])
{
Swap(&a[parent], &a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void Heapsort(int* a, int n)//时间复杂度N*LogN
{
//建小堆---降序
//建大堆---升序
for (int i = (n - 2) / 2; i >= 0; i--)
{
Adjustdown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
Adjustdown(a, end, 0);
--end;
}
}
int main()
{
int arr[] = { 7,8,3,5,1,9,5,4 };
int n = sizeof(arr) / sizeof(arr[0]);
Heapsort(arr, n);
for (int i = 0; i < n; i++)
{
printf("%d\n", arr[i]);
}
return 0;
}1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定
希尔排序( 缩小增量排序 )
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
void Shellsort(int* a, int n)
{
int gap = n;
//1. gap > 1 预排序
//2. gap == 1 直接插入排序
while (gap > 1)// 分成每gap个一组
{
gap = gap / 3 + 1; // +1 表示最后一次一定是 1
for (int i = 0; i < n - gap; i++)// 一组一组越gap进行遍历
{
int end = i; // 第一组end为0开始
int tmp = a[end + gap];
while (end >= 0)
{
if (a[end] > tmp) // a[end]大，放到后面，tmp向前插入
{
a[end + gap] = a[end];//数据挪动
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}希尔排序的特性总结：
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就
会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的
希尔排序的时间复杂度都不固定：
《数据结构(C语言版)》--- 严蔚敏
《数据结构-用面相对象方法与C++描述》--- 殷人昆
4. 稳定性：不稳定
冒泡排序
在第0次循环中：从第0个元素开始，将两个相邻的元素两两比较，如果逆序则交换顺序。这样比较n−1次（只有n−1个数对）以后，最后的元素就是最大的元素。
这样依次进行n−1次循环，这样序列就有序了。
void bubbleSort(int a[],int n)
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n-1-i;j++)
{
if(a[j+1]<a[j])
swap(a[j+1],a[j]);
//如果出现逆序就交换
}
}
}
冒泡排序的特性总结：
1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定
快速排序
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
//三数取中
int GetMidIndex(int* a, int left, int right)
{
int mid = (right + left) / 2;
if (a[left] < a[mid])
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return right;
}
else
{
return left;
}
}
else // a[left] > a[mid]
{
if (a[mid] < a[right])
{
return left;
}
else if (a[right] < a[left])
{
return right;
}
else
{
return mid;
}
}
}
//hoare法
int part_sort1(int* a, int left, int right)
{
int midi = GetMidIndex(a, left, right);
Swap(&a[left],&a[midi]);
int keyi = left;
while (left < 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]);
return left;
}
//挖坑hole法
int part_sort2(int* a, int left, int right)
{
int key = a[left];
int hole = left;
while (left < right)
{
while (left < right && a[right] >= key)
{
right--;
}
a[hole] = a[right];
hole = right;
while (left < right && a[left] <= key)
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = key;
return hole;
}
//前后指针法
int part_sort3(int* a, int left, int right)
{
int keyi = left;
int cur = left + 1;
int prev = left;
while (cur <= right)
{
if (a[cur] < a[keyi])
{
prev++;
Swap(&a[cur], &a[prev]);
}
cur++;
}
Swap(&a[keyi], &a[prev]);
prev = keyi;
return keyi;
}
void quick_sort(int* a, int begin, int end)
{
if (begin >= end)
return;
int key = part_sort1(a, begin, end);
//int key = part_sort2(a, begin, end);
//int key = part_sort3(a, begin, end);
quick_sort(a, begin, key - 1);
quick_sort(a, key + 1, end);
}
int main()
{
int arr[] = { 4,1,9,3,6,5,8,3,2,0 };
int n = sizeof(arr) / sizeof(arr[0]);
quick_sort(arr, 0, n - 1);
for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
return 0;
}简便模板：
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 1e6 + 10;
int q[N];
int n;
void quick_sort(int q[],int l,int r)
{
if(l >= r) return;
int i = l - 1, j = r + 1;
int x = q[l + r >> 1];
while(i < j)
{
do i++; while(q[i] < x);
do j--; while(q[j] > x);
if(i < j) swap(q[i],q[j]);
}
quick_sort(q, l, j);
quick_sort(q, j + 1, r);
}
int main()
{
scanf("%d",&n);
for(int i = 0; i < n; i++) scanf("%d",&q[i]);
quick_sort(q, 0, n - 1);
for(int i = 0; i < n; i++) printf("%d ",q[i]);
return 0;
}栈模拟非递归版本（注意：前提是引用已经写好的栈的实现）
例如下：
//stack.h
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<stdio.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}SK;
//初始化
void STInit(SK* pst);
//入栈
void STPush(SK* pst, STDataType x);
//出栈
void STPop(SK* pst);
//获取栈顶元素
STDataType STTop(SK* pst);
//获取栈中有效元素个数
bool STempty(SK* pst);
//检测栈是否为空，如果为空返回非0结果，如果不为空则返回非0
void STDestroy(SK* pst);
//销毁栈
int STsize(SK* pst);
//记录栈中元素//stack.c
#include"statck.h"
void STInit(SK* pst)
{
assert(pst);
pst->a = NULL;
pst->capacity = 0;
pst->top = 0;
}
void STDestroy(SK* pst)
{
assert(pst);
free(pst->a);
pst->top = pst->capacity = 0;
}
void STPush(SK* pst,STDataType x)
{
assert(pst);
if (pst->top == pst->capacity)
{
int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
STDataType* temp = (STDataType*)realloc(pst->a, newcapacity*sizeof(STDataType));
if (temp == NULL)
{
perror("realloc fail");
return;
}
pst->a = temp;
pst->capacity = newcapacity;
}
pst->a[pst->top] = x;
pst->top++;
}
void STPop(SK* pst)
{
assert(pst);
assert(!STempty(pst));
pst->top--;
}
STDataType STTop(SK* pst)
{
assert(pst);
assert(!STempty(pst));
return pst->a[pst->top - 1];
}
bool STempty(SK* pst)
{
return pst->top == 0;
}
int STsize(SK* pst)
{
assert(pst);
return pst->top;
}主体快排实现：
#include"stack.h"
void Swap(int* x, int* y)
{
int temp = *x;
*x = *y;
*y = temp;
}
int part_sort1(int* a, int left, int right)
{
int keyi = left;
while (left < 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]);
return left;
}
void QuickSortNonR(int* a, int begin, int end)
{
SK st;
STInit(&st);
STPush(&st, end);
STPush(&st, begin);
while (!STempty(&st))
{
int left = STTop(&st);
STPop(&st);
int right = STTop(&st);
STPop(&st);
int keyi = part_sort1(a, left, right);
//[left , keyi - 1] keyi [keyi + 1, right]
if (keyi + 1 < right)
{
STPush(&st, right);
STPush(&st, keyi + 1);
}
if (left < keyi - 1)
{
STPush(&st, keyi - 1);
STPush(&st, left);
}
}
STDestroy(&st);
}
int main()
{
int a[] = { 6,1,2,7,9,8,3,5,4 };
int n = sizeof(a) / sizeof(a[0]);
QuickSortNonR(a, 0, n - 1);
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
return 0;
}快速排序的特性总结：
1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)
4. 稳定性：不稳定
归并排序
基本思想：
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：
#include<stdio.h>
#include<stdlib.h>
void _mergesort(int *a, int begin, int end, int* tmp)
{
if (begin >= end)
return;
int mid = begin + end >> 1;
_mergesort(a, begin, mid, tmp);
_mergesort(a, mid + 1, end, tmp);
//归并两个区间
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
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 <= end2)
{
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);
_mergesort(a, 0, n - 1, tmp);
free(tmp);
}
int main()
{
int arr[] = { 9,2,3,4,1,5,6,0,10 };
mergesort(arr, sizeof(arr) / sizeof(arr[0]));
for (int i = 0; i < sizeof(arr)/sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
return 0;
}简便模板：
#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int q[N],temp[N];
int n;
void merge_sort(int q[], int l, int r)
{
if (l >= r) return;
int mid = l + r >> 1;
merge_sort(q, l, mid), merge_sort(q, mid + 1, r);
int k = 0, i = l, j = mid + 1;
while (i <= mid && j <= r)
if (q[i] < q[j]) temp[k++] = q[i++];
else temp[k++] = q[j++];
while (i <= mid) temp[k++] = q[i++];
while (j <= r) temp[k++] = q[j++];
for (int i = l, j = 0; i <= r; i++, j++) q[i] = temp[j];
}
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &q[i]);
merge_sort(q,0,n-1);
for (int i = 0; i < n; i++) printf("%d ", q[i]);
return 0;
}归并排序非递归版本
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
void mergeNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail");
return;
}
//1 2 4 ....
int gap = 1;
while (gap < n)
{
int j = 0;
for (int i = 0; i < n; i += 2 * gap)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
printf("[%d,%d][%d,%d]\n", begin1, end1, begin2, end2);
//三种情况：
//1.end1 begin2 end2全部越界
//2.begin2 end2 全部越界
//3.end2 全部越界
//修正方法1: 1和2的情况下直接break，剩下的数直接拷贝下去
// 3的情况下直接将归并的子区间末尾设置为数组的最后一个数再进行归并
//修正方法2: 直接修正其区间，将越界的区间直接设置为不存在
/*if (end1 >= n || begin2 >= n)
{
break;
}
if (end2 >= n)
{
end2 = n - 1;
}*/
if (end1 >= n)
{
end1 = n - 1;
//不存在的区间
begin2 = n;
end2 = n - 1;
}
else if(begin2 >= n)
{
begin2 = n;
end2 = n - 1;
}
else if(end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] <= a[begin2])
{
tmp[j++] = a[begin1++];
}
else
{
tmp[j++] = a[begin2++];
}
}
while (begin1 <= end1)
tmp[j++] = a[begin1++];
while (begin2 <= end2)
tmp[j++] = a[begin2++];
memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
}
printf("\n");
gap *= 2;
}
free(tmp);
}
int main()
{
int arr[] = { 1,9,2,6,3,4,7,5,6 };
int n = sizeof(arr) / sizeof(arr[0]);
mergeNonR(arr, n);
for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
return 0;
}归并排序的特性总结：
1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
4. 稳定性：稳定
计数排序
思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：
1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
void Countsort(int* a, int n)
{
//取出最大最小值确定范围
int max = a[0];
int min = a[0];
for (int i = 0; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
if (a[i] < min)
{
min = a[i];
}
}
int range = max - min + 1;
int* countA = (int*)malloc(sizeof(int) * range);
memset(countA, 0, sizeof(int) * range);//对countA的元素进行初始化
//计数
for (int j = 0; j < n; j++)
{
countA[a[j] - min]++;
}
//存入数组并排序
int k = 0;
for (int i = 0; i < range; i++)
{
while (countA[i]--)
{
a[k++] = i + min;
}
}
}
int main()
{
int arr[] = { 9,1,3,6,2,7,5,8 };
int n = sizeof(arr) / sizeof(arr[0]);
Countsort(arr, n);
for (int i = 0; i < n; i++)
{
printf("%d ", arr[i]);
}
return 0;
}计数排序的特性总结：
1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
总结：各个排序算法的复杂度
以上便是所学的排序的全部实现！
88
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
