一、交换排序（冒泡排序、快速排序）
二、选择排序（直接选择排序、堆排序）
三、插入排序（直接插入排序、希尔排序）
四、归并排序
五、计数排序
排序的概念
排序： 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
稳定性： 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
内部排序： 数据元素全部放在内存中的排序。
外部排序： 数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
一、交换排序
1.基本思想
通过对比两个值的大小，来交换这两个值在序列中的位置
2.冒泡排序
思路：对比两个相邻的数据进行交换，每次固定一个最大值或者最小值位置，再将判断范围缩小
void swap(int* a,int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}
void BubbleSort(int* a, int n)
{
assert(a);
for (int i = 0; i < n; i++)
{
int exchange = 0;
for (int j = 1; j < n - i; j++)
{
//升序
if (a[j - 1] > a[j])
{
swap(&a[j - 1], &a[j]);
exchange++;//标识 如果一次遍历后值为0，则数组为有序，退出循环
}
//降序
//if (a[j - 1] < a[j])
//{
//swap(&a[j - 1], &a[j]);
//exchange++;
//}
}
if (exchange == 0)
{
break;
}
}
}
3.快速排序
快速排序的基本实现思路，是在序列中选定一个基准值，将整个序列分为两部分。
升序：左序列小于基准值，右序列大于基准值
降序：左序列大于基准值，左序列小于基准值
（1）.hoare版本
思路：（例）将数组第一个元素记为key值，先从右向左找到第一个小于key的值，再从左向右遍历找到第一个大于key的值，二者交换。最后，当left>=right,循环退出，将key值插入当前left的位置。（以最左端为基准值，那么先从右侧开始查找）。
给出以下数据 6 1 2 5 9 3 4 5 10 8
一次遍历交换的结果如图所示
int PartSort1(int* a, int left, int right)
{
assert(a);
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[keyi], &a[left]);
return left;
}
（2）.挖坑法
思路：（例）保存数组第一个位置的值，记为key；从右向左找到第一个小于key的值，，将这个值插入key所在的位置，此时这个值所在位置可以看做一个坑位（没有数据，用pit这个变量记录坑位的下标）；再从左向右找到第一个大于key的值，将这个值插入当前的坑位；重复上述步骤，直到left>=right，循环结束，把key插入当前的坑位。
int PartSort2(int* a, int left, int right)
{
assert(a);
int key = a[left];//将基准值保存起来
int pit = left;
while (left < right)
{
while (left < right && a[right] >= key)
{
right--;
}
a[pit] = a[right];
pit = right;
while (left < right && a[left] <= key)
{
left++;
}
a[pit] = a[left];
pit = left;
}
a[pit] = key;
return pit;
}
（3）前后指针法
记数组第一个元素为key，prev指针指向数组起始位置，cur指针指向prev的下一个位置，prev向后遍历找到以一个小于key的值，cur向后遍历找到第一个大于key的值，二者交换，直到cur超过right，结束。
int PartSort3(int* a, int left, int right)
{
assert(a);
int prev = left;
int cur = left+1;
int key = a[left];
while (cur <= right)
{
if (a[cur]<key && a[++prev]!= a[cur])
swap(&a[cur], &a[prev]);
cur++;
}
swap(&a[left], &a[prev]);
return prev;
}
快速排序整体实现
//三数取中（左端点、右端点、中间值，三个取一个最大值或者最小值）
int GetMid(int* a,int left,int right)
{
int mid = left + (right - left) / 2;
if (a[mid] < a[left])
{
if (a[mid] > a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return left;
}
else
{
return right;
}
}
else
{
if (a[mid] < a[right])
{
return mid;
}
else if (a[left] < a[right])
{
return right;
}
else
{
return left;
}
}
}
//
int PartSort3(int* a, int left, int right)
{
assert(a);
int midi = GetMid(a, left, right);//三数取中
swap(&a[left], &a[midi]);
int prev = left;
int cur = left+1;
int key = a[left];
while (cur <= right)
{
if (a[cur]<key && a[++prev]!= a[cur])
swap(&a[cur], &a[prev]);
cur++;
}
swap(&a[left], &a[prev]);
return prev;
}
void Quicksort(int* a, int left, int right)
{
if (left > right)
return;
int pos = PartSort3(a, left, right);//上述三个函数均可
Quicksort(a, left, pos - 1);
Quicksort(a, pos + 1, right);
}
(4）非递归实现
// 快速排序 非递归实现
void QuickSortNonR(int* a, int begin, int end)
{
ST s;//使用辅助数据结构实现（栈）
StackInit(&s);//栈初始化
StackPush(&s,begin);
StackPush(&s,end);
while (!StackEmpty(&s))
{
int end = StackTop(&s);
StackPop(&s);
int begin = StackTop(&s);
StackPop(&s);
int keyi = PartSort3(a, begin, end);//调用上述三个方法均可
if (begin < keyi - 1)
{
StackPush(&s, begin);
StackPush(&s, keyi - 1);
}
if (end > keyi + 1)
{
StackPush(&s, keyi + 1);
StackPush(&s, end);
}
}
StackDestory(&s);
}
快速排序的特性总结：
- 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
- 时间复杂度：O(N*logN)
- 空间复杂度：O(logN)
- 稳定性：不稳定
二、选择排序
1.基本思想
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完 。
2.直接选择排序
思路：
在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素
void SelectSort(int* a, int n)
{
assert(a);
int left = 0, right = n - 1;
while (left < right)
{
int mini = left, maxi = left;//选择两个数（最大的和最小的，提高效率）
for (int i = left; i <= right; i++)
{
if (a[i] < a[mini])
{
mini = i;
}
if (a[i] > a[maxi])
{
maxi = i;
}
}
swap(&a[left], &a[mini]);
if (left == maxi)
maxi = mini;
swap(&a[right], &a[maxi]);//swap（）见冒泡排序代码
left++;
right--;
}
}
3.堆排序
//建堆
void AdjustDown(int* a, size_t size, size_t root)
{
assert(a);
size_t parent = root;
size_t child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && a[child + 1] > a[child])
{
child++;
}
if (a[child] > a[parent])
{
swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int n)
{
assert(a);
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--;
}
}
三、插入排序
1.基本思想
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。
2.直接插入排序
思路：当插入第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)
{
assert(a);
for (int i = 0; i < n-1; i++)
{
int end = i;
int tmp = a[end + 1];
while (end>=0)
{
if (tmp < a[end])
{
a[end + 1] = a[end];
end--;
}
else
{
break;
}
}
a[end + 1] = tmp;
}
}
3.希尔排序
思路：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
void ShellSort(int* a, int n)
{
assert(a);
int gap = n;
while (gap > 1)
{
gap = gap / 3 + 1;//每次缩小选择的数据间的距离
for (int i = 0; i < n - gap; i++)
{
int end = i;
int tmp = a[end + gap];
while (end >= 0)
{
if (tmp < a[end])
{
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
a[end + gap] = tmp;
}
}
}
四、归并排序
1.思路： 归并排序本质就是合并两个有序数组，当数组无序时，将数组不断二分，再进行有序数组合并，每次递归返回时，数组的一部分将变得有序。
2.递归实现
void _MergeSort(int* a,int begin ,int end,int* tmp)
{
if (begin >= end)
return;
int mid = (begin + end) / 2;
_MergeSort(a, begin, mid, tmp);
_MergeSort(a, mid + 1, end, tmp);
int begin1 = begin, end1 = mid;
int begin2 = mid + 1, end2 = end;
int index = begin;
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++];
}
memcpy(a + begin, tmp + begin, (end - begin + 1) * sizeof(int));
}
void MergeSort(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
exit(-1);
_MergeSort(a, 0, n - 1, tmp);
free(tmp);
}
3.非递归实现
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)
{
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;
int index = i;
//end1越界
if (end1 >= n)
end1 = n - 1;
//begin2越界
if (begin2 >= n)
{
begin2 = n ;
end2 = n - 1;
}
//end2越界
if (begin2<n && 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++];
}
}
memcpy(a, tmp, n * sizeof(int));
gap *= 2;
}
free(tmp);
}
归并排序的特性总结：
- 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
- 时间复杂度：O(N*logN)
- 空间复杂度：O(N)
- 稳定性：稳定
五、计数排序
思想： 计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：
- 统计相同元素出现次数
- 根据统计的结果将序列回收到原来的序列中
void CountSort(int* a, int n)
{
int min = a[0], max = a[0];
for (int i = 1; i < n; i++)
{
if (min > a[i])
min = a[i];
if (max < a[i])
max = a[i];
}
int range = max - min + 1;
int* countArr = (int*)malloc(sizeof(int) * range);
assert(countArr);
memset(countArr, 0, sizeof(int)*range);
for (int i = 0; i < n; i++)
{
countArr[a[i] - min]++;
}
int pos = 0;
for (int i = 0; i < n; i++)
{
while (countArr[i]--)
{
a[pos++] = i + min;
}
}
free(countArr);
}
计数排序的特性总结：
- 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
- 时间复杂度：O(MAX(N,范围))
- 空间复杂度：O(范围)
3101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
