总结
插入、选择、冒泡对比
时间与空间复杂度
稳定性对比
插入排序
// 插入排序
// 最好：O(N) -- 顺序有序或者接近有序
// 时间复杂度：O(N^2)
// 空间复杂度：O(1)
// 稳定性：稳定
void InsertSort(int* a, int n)
{
for (int i = 0; i < n - 1; i++)
{
int end = i;
int x = a[end + 1];
while (end >= 0)
{
if (a[end] > x)
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = x;
}
}
希尔排序（优化了插入排序）
// 希尔排序 时间复杂度O(N^1.3) 数据量越大效果越明显
// 稳定性：不稳定
//思想： 元素集合越接近有序，直接插入排序算法的时间效率越高， 所以：将插入排序每次的间隔从1扩大到gap， 然后每个元素与gap距离的元素进行插入排序， 最后gap--到1， 完成最后一次插入排序
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1; //保证最后能是1
// 多次预排序(gap > 1) +直接插入 (gap == 1)
// 多组一锅炖
for (int i = 0; i < n - gap; i++)
{
int end = i;
int x = a[end + gap];
while (end >= 0)
{
if (a[end] > x)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = x;
}
}
}
选择排序（最拉跨的一个排序）
// 选择排序
// 时间复杂度：O(N^2)
// 最好：O(N^2)
// 整体而言最差的排序，因为无论什么情况都是O(N^2)
// 思想：每一次从待排序的数据元素中选出最小与最大的一个元素，存放在序列的起始与末尾位置，直到全部待排序的数据元素排完 。
void SelectSort(int* a, int n)
{
int begin = 0;
int end = n - 1;
while (begin < end)
{
int mini = begin;
int maxi = begin;
for (int i = begin; i <= end; i++)
{
if (a[i] < a[mini])
mini = i;
if (a[i] > a[maxi])
maxi = i;
}
Swap(&a[begin], &a[mini]);
// 注意：begin == maxi时，最大被换走了，因此需要修正一下maxi的位置
if (begin == maxi)
maxi = mini;
Swap(&a[end], &a[maxi]);
begin++;
end--;
}
}
堆排序（我的博客里有专门讲这个的）
//向上建堆的时间复杂度为O(N*logN)
//向下建堆的时间复杂度为O(N)
void AdjustDown(int* a, int n, int parent)
{
int child = parent * 2 + 1;
while (child < n)
{
if (child + 1 < n && a[child + 1] > a[child])
{
child++;
}
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
// 堆排序 O(N*logN)
// 建堆 : 升序建大堆 降序建小堆
void HeapSort(int* a, int n)
{
//先建堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
//
for (int i = n - 1; i >= 0; i--)
{
Swap(&a[0], &a[i]);
AdjustDown(a, i, 0);
}
}
冒泡排序
// 冒泡排序
// 时间复杂度：O(N^2)
// 最好：O(N)
void BubbleSort(int* a, int n)
{
int end = n;
int flag;
while (end > 0)
{
flag = 0;
for (int i = 1; i < end; i++)
{
if (a[i - 1] > a[i])
{
flag = 1;
Swap(&a[i - 1], &a[i]);
}
}
end--;
if (flag == 0)//当flag等于0证明本次冒泡没有交换数据，那么证明已经有序了可以break了
break;
}
}
快速排序（重点）
三数取中法
//三数取中法
int GetMid(int *a, int left, int right)
{
int mid = (left + right) / 2;
if (a[left] < a[mid])
{
if (a[left] < a[right])
{
if (a[mid] < a[right])
return mid;
else
return right;
}
else
return left;
}
else
{
if (a[left] > a[right])
{
if (a[mid] > a[right])
return mid;
else
return right;
}
else
return left;
}
}
hoare版本最原始版本
// 快速排序递归实现
// 快速排序hoare版本
// hoare版本
// [left, right]
// 走一趟O(N)
//左边为key 右边先走，右边找大， 左边找小，相遇交换key
int PartSort1(int* a, int left, int right)
{
// 三数取中 -- 面对有序最坏情况，变成选中位数做key，变成最好情况
int mini = GetMid(a, left, right);
Swap(&a[mini], &a[left]);
int key = left;
while (left < right)
{
// 右边先走，找小
//left < right 为了解决 5 6 7 8 9 有序场景
//加 = 为了解决 5 5 5 5 5 相等的场景
while (left < right && a[right] >= a[key])
right--;
//左边再走，找大
while (left < right && a[left] <= a[key])
left++;
Swap(&a[left], &a[right]);
}
//相遇了
Swap(&a[key], &a[left]);
//返回相遇位置
return left;
}
// O(N*logN)
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
int key = PartSort1(a, left, right);
QuickSort(a, left, key - 1);
QuickSort(a, key + 1, right);
}
挖坑法
//挖坑法
int PartSort2(int* a, int left, int right)
{
// 三数取中 -- 面对有序最坏情况，变成选中位数做key，变成最好情况
int mini = GetMid(a, left, right);
Swap(&a[mini], &a[left]);
int key = a[left];
int pivot = left;//坑位
while (left < right)
{
// 右边找小, 放到左边的坑里面
while (left < right && a[right] >= key)
right--;
a[pivot] = a[right];
pivot = right;
// 左边找大，放到右边的坑里面
while (left < right && a[left] <= key)
left++;
a[pivot] = a[left];
pivot = left;
}
a[pivot] = key;
return pivot;
}
// O(N*logN)
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
int key = PartSort2(a, left, right);
QuickSort(a, left, key - 1);
QuickSort(a, key + 1, right);
}
双指针法（这个最简洁）
//双指针法 推荐掌握这个 -- 思想三种大家都要掌握
int PartSort3(int* a, int left, int right)
{
// 三数取中 -- 面对有序最坏情况，变成选中位数做key，变成最好情况
int mini = GetMid(a, left, right);
Swap(&a[mini], &a[left]);
int key = left;
int prev = left;
int cur = left + 1;
while (cur <= right)
{
/*if (a[cur] < a[key])
{
Swap(&a[cur], &a[++prev]);
}*/
if (a[cur] < a[key] && ++prev != cur)//这一步避免了无效的交换
{
Swap(&a[cur], &a[prev]);
}
cur++;
}
Swap(&a[prev], &a[key]);
return prev;
}
// O(N*logN)
void QuickSort(int* a, int left, int right)
{
if (left >= right)
return;
int key = PartSort3(a, left, right);
QuickSort(a, left, key - 1);
QuickSort(a, key + 1, right);
}
快排的非递归（防止递归深度太深栈溢出）
// 快速排序 非递归实现
// 递归深度太深的程序，只能考虑改非递归
void QuickSortNonR(int* a, int left, int right)
{
stack<int> st;
st.push(left);
st.push(right);
while (!st.empty())
{
int end = st.top();
st.pop();
int begin = st.top();
st.pop();
int keyi = PartSort3(a, begin, end);
// [begin, keyi-1] keyi [keyi+1, end]
if (keyi + 1 < end)
{
st.push(keyi + 1);
st.push(end);
}
if (begin < keyi - 1)
{
st.push(begin);
st.push(keyi - 1);
}
}
}
归并排序（需要借助数组，开辟额外空间）
1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(N)
归并递归版本
void _MergeSort(int * a, int left, int right, int * tmp)
{
if (left >= right)
return;
int mid = (left + right) / 2;
// [left, mid] [mid+1, right] 有序
_MergeSort(a, left, mid, tmp);
_MergeSort(a, mid + 1, right, tmp);
int begin1 = left, end1 = mid;
int begin2 = mid + 1, end2 = right;
int i = left;
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++];
}
for (int i = left; i <= right; i++)
{
a[i] = tmp[i];
}
}
// 归并排序递归实现
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int)*n);
if (tmp == NULL)
{
printf("malloc fail\n");
exit(-1);
}
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
tmp = NULL;
}
归并排序非递归考虑边界情况不全版（当n不是2的次方时需要边界考虑）
上面没有考虑不是2的次方倍，因此存在越界风险
当n不是2的次方时有以下情况
处理方法
归并排序非递归最终正确版
// 归并排序非递归实现
// n不是2的次方时需要考虑边界
void MergeSortNonR(int* a, int n)
{
int * tmp = (int*)malloc(sizeof(int)*n);
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
// [i,i+gap-1] [i+gap,i+2*gap-1] 归并区间
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
int index = i;
// 核心思想：end1、begin2、end2都有可能越界
// end1越界 或者 begin2 越界都不需要归并
if (end1 >= n || begin2 >= n)
{
break;
}
// end2 越界，需要归并，修正end2
if (end2 >= n)
{
end2 = n - 1;
}
while (begin1 <= end1 && begin2 <= end2)
{
if (a[begin1] < a[begin2])
tmp[index++] = a[begin1++];
else
tmp[index++] = a[begin2++];
}
while (begin1 <= end1)
{
tmp[index++] = a[begin1++];
}
while (begin2 <= end2)
{
tmp[index++] = a[begin2++];
}
// 把归并小区间拷贝回原数组
for (int j = i; j <= end2; j++)
{
a[j] = tmp[j];
}
}
gap *= 2;
}
free(tmp);
tmp = nullptr;
}
计数排序
// 计数排序
// 时间复杂度：O(Max(N, Range))
// 空间复杂度：O(range)
// 适合范围比较集中的整数数组
// 范围较大，或者是浮点数等等都不适合排序了
void CountSort(int* a, int n)
{
int mini = a[0], maxi = a[0];
for (int i = 0; i < n; i++)
{
if (a[i] < mini)
mini = a[i];
if (a[i] > maxi)
maxi = a[i];
}
int range = maxi - mini + 1;
int * count = (int *)malloc(sizeof(int)*range);
memset(count, 0, sizeof(int)*range);
// 统计次数
for (int i = 0; i < n; i++)
{
count[a[i] - mini]++;
}
// 根据次数，进行排序
int j = 0;
for (int i = 0; i < range; i++)
{
while (count[i]--)
{
a[j++] = i + mini;
}
}
}
扫一扫
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
