常见排序及其代码
插入排序
直接插入排序
void Print(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void InsertSort(int* a, int n)
{
for (int i = 0; i < n-1; i++)
{
int end = i;
int tmp = a[i + 1];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
int main()
{
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
InsertSort(a, sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
希尔排序
希尔排序可以说是插入排序的升级版，效率更高，也叫缩小增量法。他会先找一个整数，分为整数个组，整数不断减少，直到等于1时，即排成序列。
void Print(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void ShellSort(int* a, int n)
{
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;
for (int j = 0; j < gap; j++)
{
for (int i = j; i < n - gap; i += gap)
{
int end = i;
int tmp = a[i + gap];
while (end >= 0)
{
if (a[end] > tmp)
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
}
int main()
{
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
ShellSort(a, sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
选择排序
选择排序
从数组中选出最小值和最大值，分别与两端交换。
也会有一种特殊情况：start==max，这时start与min交换了，max的位置应在min上了。
void Print(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void SelectSort(int* a, int n)
{
int start = 0;
int end = n - 1;
while (start < end)
{
int max = start, min = start;
for (int i = start; i <= end; i++)
{
if (a[max] < a[i])
{
max = i;
}
if (a[min] > a[i])
{
min = i;
}
}
swap(&a[min], &a[start]);
if (start == max)
{
max = min;
}
swap(&a[max], &a[end]);
end--;
start++;
}
}
int main()
{
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
SelectSort(a, sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
堆排序
建小堆需建大堆，
排序时a[0]与a[end]交换，把最大的放在最后，end–，再把次最大的放在第一个，然后再调整把次最大的放在倒数第二个。
void Print(int* a, int n)
{
for (int i = 0; i < n; i++)
{
printf("%d ", a[i]);
}
printf("\n");
}
void swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void AdjustDown(int* a, int n, int parent)
{
int child = 2 * parent + 1;
while (child < n)
{
if (child + 1 < n && a[child] < a[child + 1])
{
child++;
}
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
}
parent = child;
child = 2 * parent + 1;
}
}
void HeapSort(int* a, int n)
{
//升序建大堆
for (int i = (n - 1 - 1) / 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 a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
HeapSort(a, sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
交换排序
冒泡排序
void swap(int* p1, int* p2)
{
int tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
void BubbleSort(int* a, int n)
{
for (int i = 0; i < n; i++)
{
bool ret = false;
for (int j = 1; j < n - i; j++)
{
if (a[j - 1] > a[j])
{
swap(&a[j - 1], &a[j]);
ret = true;
}
}
if (ret == false)
{
break;
}
}
}
int main()
{
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
BubbleSort(a, sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
快速排序
提供三种方法：
1.hoare
先把keyi定在左边，从右边往左边找小，找到即停止，从右往左找大，找到即停止，进行交换，重复操作，直到left<right条件不符合，最终停止的位置必定小于keyi。
int PartSort1(int* a, int left, int right)
{
int keyi = left;
while (left < right)
{
if (left<right && a[right]>=a[keyi])
{
right--;
}
if (left<right && a[left]<=a[keyi])
{
left++;
}
swap(&a[left], &a[right]);
}
swap(&a[left], &a[keyi]);
return left;
}
2.挖坑法
先最左边，挖坑，从右边开始找小，找到即停止，与坑交换，坑的位置变为右边的位置。
int PartSort2(int* a, int left, int right)
{
int keyi = a[left];
int hole = left;
while (left < right)
{
if (left<right && a[right] >= keyi)
{
right--;
}
a[hole] = a[right];
hole = right;
if (left < right && a[left] <= keyi)
{
left++;
}
a[hole] = a[left];
hole = left;
}
a[hole] = keyi;
return hole;
}
3.前后指针
设置两个前后指针prev cur，用cur找小的，找到就和++prev交换，然后++cur
int PartSort3(int* a, int left, int right)
{
int prev = left;
int cur = left + 1;
int keyi = left;
while (cur <= right)
{
if (a[cur] < a[keyi] && ++prev != cur)
{
swap(&a[cur], &a[prev]);
}
cur++;
}
swap(&a[prev], &a[keyi]);
keyi = prev;
return keyi;
}
最总递归
void QuickSort(int* a, int begin,int end)
{
if (begin >= end)
{
return;
}
int keyi = PartSort1(a, begin, end);
QuickSort(a, begin, keyi-1);
QuickSort(a, keyi+1, end);
}
归并排序
归并排序
采用分治法
非递归：
#include <string.h>
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
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;
if (end1 >= n || begin2 >= n)
{
break;
}
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));
}
gap *=2;
}
free(tmp);
}
int main()
{
int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
MergeSortNonR(a,sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
递归：
void _MergeSort(int* a, int start, int end, int* tmp)
{
if (start == end)
{
return;
}
int mid = (start + end) / 2;
_MergeSort(a, start, mid, tmp);
_MergeSort(a, mid+1, end, tmp);
int begin1 = start, end1 = mid;
int begin2 = mid + 1, end2 = end;
int i = start;
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 + start, tmp + start, sizeof(int) * (end - start + 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 a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
MergeSort(a,sizeof(a) / sizeof(a[0]));
Print(a, sizeof(a) / sizeof(a[0]));
return 0;
}
算法复杂度及稳定性
| 排序方法 | 平均情况 | 稳定性 |
|---|---|---|
| 冒泡排序 | O（n^2） | 稳定 |
| 选择排序 | O（n^2） | 不稳定 |
| 插入排序 | O（n^2） | 稳定 |
| 希尔排序 | O（nlogn）~ O（n^2） | 不稳定 |
| 堆排序 | O（nlogn） | 不稳定 |
| 归并排序 | O（nlogn） | 稳定 |
| 快速排序 | O（nlogn） | 不稳定 |
~~ 码字不容易，点赞在走奥 ~~
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
