排序算法
汇总
插入排序
void InsertSort(int A[], int n) //时间复杂度O(n)O(n^2) 空间复杂度O(1) 稳定性 稳定
{//直接插入 从后面拿一个往前面插 定位置时暴力
for (int i = 2; i <= n; i++) //设第一个元素为排好的序列
{
if (A[i] < A[i - 1]) //与排好序列的最后一个比较
{
A[0] = A[i]; //暂存数据 也为下面跳出循环做准备
int j;
for (j = i - 1; A[0] < A[j]; --j) //从排好的序列最后找
A[j + 1] = A[j]; //边找边移
A[j + 1] = A[0]; //将值 赋值到已找到的位置
}
}
}
void Insert_Sort(int A[], int n) //时间复杂度O(nlogn)O(n^2) 空间复杂度O(1) 稳定性 稳定
{//折半插入 从后面拿一个往前面插 定位置时二分
for (int i = 2; i <= n; i++) //设第一个元素为排好的序列
{
if (A[i] < A[i - 1]) //与排好序列的最后一个比较
{
A[0] = A[i]; //暂存数据 也为下面作比较做准备
int low = 1, high = i - 1;
while (low <= high)
{ //查到第一个大于A[0]的数据
int mid = (low + high) / 2;
if (A[mid] > A[0])
high = mid - 1;
else
low = mid + 1;
} //利用二分定位尽头high+1
int j;
for (j = i - 1; j >= high + 1; --j) //倒着移动 尽头为high+1
A[j + 1] = A[j];
A[j + 1] = A[0]; //将值 赋值到已找到的位置
}
}
}
希尔排序
void ShellSort(int A[], int n) //时间复杂度O() O(n^2) 空间复杂度O(1) 稳定性 不稳定
{//希尔排序 先分成好几个组 在每个组内进行插入排序 组数减少后再排序
for (int dk = n / 2; dk >= 1; dk /= 2) //设置步长 dk=3则1 4 7一组 然后dk变2 则1 3 5 7一组
{
for (int i = dk + 1; i <= n; i++) //设组内第一个元素为排好的序列
{
if (A[i] < A[i - dk]) //与组内排好序列的最后一个比较
{
A[0] = A[i]; //暂存数据
int j;
for (j = i - dk; j > 0 && A[0] < A[j]; j -= dk) //从组内排好的序列最后找
A[j + dk] = A[j]; //边找边移
A[j + dk] = A[0]; //将值 赋值到已找到的位置
}
}
}
}
冒泡排序
void BubbleSort(int A[], int n) //时间复杂度O(n^2) 空间复杂度O(1) 稳定性 稳定
{
for (int i = 1; i < n; i++) //走n-1趟 第n趟的数值一定在最大位
{
bool flag = false; //每一趟的标记 用来简化时间复杂度
for (int j = n; j > i; j--) //从最后开始 换不换都向前走 类似于部分优化
if (A[j] < A[j - 1]) //从最后开始找 与前一个比
swap(A[j - 1], A[j]), flag = true; //必前面小的话跟前面的换
if (!flag) //走了一趟没有交换 直接跳
return;
}
}
快速排序
int Partition(int A[], int low, int high)
{
int temp = A[low]; //先确定一个数 作为轴 想象成low位已空
while (low < high)
{
while (low < high && A[high] >= temp)
high--;
A[low] = A[high]; //找到一个比轴大的 补到low位 high位已空
while (low < high && A[low] <= temp)
low++;
A[high] = A[low]; //找到一个比轴小的 补到high位 low位已空
}
A[low] = temp; //最后的空位由轴补
return low; //返回轴
}
void QuickSort(int A[], int low, int high) //时间复杂度O(nlogn) 空间复杂度O(1) 稳定性 不稳定
{
if (low < high) //还没分到尽
{
int p = Partition(A, low, high); //一个数组变两个 但数组的大小不定
QuickSort(A, low, p - 1); //前一个数组
QuickSort(A, p + 1, high); //后一个数组
}
}
选择排序
void SelectSort(int A[], int n) //时间复杂度O(n^2) 空间复杂度O(1) 稳定性 不稳定
{
for (int i = 1; i < n; i++) //走n-1趟
{
int min = i; //记录最小元素位置
for (int j = i + 1; j <= n; j++) //从后面开始找
if (A[j] < A[min])
min = j;
if (min != i) //如果第一个不是最小的 换
swap(A[i], A[min]);
}
}
堆排序
void HeadAdjust(int A[], int k, int n)
{ //大堆调整
A[0] = A[k]; //根数据暂存
for (int i = 2 * k; i <= n; i *= 2) //每次循环后 若还能走 则必定k=i
{
if (i < n && A[i] < A[i + 1]) //两孩子比较 取大 定的左孩子故不可=n
i++;
if (A[0] >= A[i]) //根大于两个孩子中较大的
break;
else
A[k] = A[i], k = i; //根小了 孩子往里塞 空位为孩子位 将来要补的位
}
A[k] = A[0]; //暂存数据归位
}
void BuildMaxHeap(int A[], int n)
{ //优化数组成大堆
for (int i = n / 2; i > 0; i--) //从有孩子的结点开始 在原数组上优化成堆
HeadAdjust(A, i, n);
}
void HeapSort(int A[], int n) //时间复杂度O(nlogn) 空间复杂度O(1) 稳定性 不稳定
{ //先将数组调整至堆 在抽堆头放到该放的位置
BuildMaxHeap(A, n); //先调整成大堆
for (int i = n; i > 1; i--) //走n-1趟 每次都是拿堆顶后再优化
{
swap(A[i], A[1]); //拿堆头 放到该放的位置
HeadAdjust(A, 1, i - 1); //调整剩下的堆的元素
}
}
归并排序
void Merge(int A[],int low,int mid,int high)
{
for (int k=low;k<=high;k++)//先小小记录一下
b[k]=A[k];
int i=low,j=mid+1;//双指针预备
int k=i;
while (i<=mid&&j<=high)//两个指针都能在自己回合走
if (b[i]<=b[j])
A[k++]=b[i++];
else
A[k++]=b[j++];
while (i<=mid)//前面的部分还有活的
A[k++]=b[i++];
while (j<=high)//后面的部分还有活的
A[k++]=b[j++];
}
void MergeSort(int A[],int low,int high)//时间复杂度O(nlogn) 空间复杂度O(n) 稳定性 稳定
{//采取的2路归并
if (low<high)//懒到不会动
{
int mid=(low+high)/2;//懒到只会在中间分 2路归并
MergeSort(A,low,mid);//给下手1
MergeSort(A,mid+1,high);//给下手2
Merge(A,low,mid,high);//请函数大佬整理一下
}
}
基数排序
/**
* 基数排序 按关键字排 对于三位数 从右向左
* d:关键数数量3 n:元素数 r:关键字的可能取值数10
* 时间复杂度O(d*(n+r)) 空间复杂度O(r) 稳定性 稳定
**/