目录
一.8种排序方式总览分析（带图）
1.按方式分类（比较排序）
*计数排序：非比较排序
二.8种排序方式详细解析
1.计数排序
注意：计数排序适合范围集中，且范围不大的整型数组排序。不适合范围分散或者非整型的排序，如：字符串、浮点数 等
步骤：
1.找到原数组最大的值，记作range
2.设置一个计数数组，遍历一遍原数组O(n)，统计每个数据出现的次数。
3.遍历一遍计数数组O(range)
计数排序分为：相对映射型和非相对映射型(相对位置）
图示意：
2.冒泡排序
遍历有序区间的各个数，从其开始到结尾的区间内轮转交换，不断缩小区间。
原理：不断把大/小的数移到后面
注意点：为提高效率，当发现一次循环中没有数对交换，即可中止循环。
void BubbleSort(int*a,int n)
{
int i = 0,j=0;
for (j = 0; j<n; j++)
{
bool exchange = false;
for (i = 0; i < n-j; i++)
{
if (a[i + 1] < a[i])
{
Swap(&a[i + 1], &a[i]);
exchange = true;
}
}
//加入判断环节，提前终止，提高效率
if (exchange == false)
{
break;
}
}
}3.选择排序
遍历有序区间的各个数，找出其之后的最大/最小数并与该数之后的数进行替换。
代码的设计思路是设置left，right下标从数组两端向中间遍历，依次筛选出最大值和最小值mini，maxi，并分别与left，riight进行交换。
注意点：在交换过程中，left所处的位置可能正好被maxi标记，接下来下一步maxi与right的交换则会出错，right无法与正确的maxi交换。
解决方法：如果left和maxi重叠，交换后要修正
void SelectSort(int* a, int n)
{
int left = 0;
int right = n;
while (left < right)
{
int mini = left, maxi = right;
for (int i =left+1; i <= right; i++)
{
if (a[i] > a[maxi])
{
maxi = i;//移动下标
}
if (a[i] < a[mini])
{
mini = i;
}
}
Swap(&a[left], &a[mini]);
if (left == maxi)
{
maxi = mini;
}
Swap(&a[right], &a[maxi]);
left++;
right--;
}
}4.插入排序
遍历有序区间的各个数，把其视作临时变量tmp，分别于它前面的数进行对比，
其进一步优化即为“希尔排序”
注意点：此算法中，当tmp比第一个数大/小时，end会到-1的位置。所以采用图中标记用法。
//升序
void InsertSort(int* a, int n)//a 数组 n 个数
{
int i = 0;
for (i = 1; i < n; i++)
{
int end = i - 1;
int tmp = i;
while (end >= 0)
{
if (a[tmp] < a[end])
{
//整体后移
a[end + 1] = a[end];
--end;
}
else
{
break;
}
}
//填空
a[end + 1] = a[tmp];
}
}5.希尔排序
其可以理解为在插入排序的基础上进行预排序（分组插排）
注意点：图示辅助理解循环：
void ShellSort(int* a, int n)
{
//gap==1 插入排序
//gap>1预先排序
int gap=n;
//升序
while(gap>1)
{
gap = gap / 2;
//gap=gap/3+1 确保gap的跳跃到最后为1，
int i = 0;
for (i = 0; i < n-gap; i++)
{
int end = i;
int tmp = i+gap;
while (end >= 0)
{
if (a[tmp] < a[end])
{
//整体后移
a[end + gap] = a[end];
end -= gap;
}
else
{
break;
}
}
//填空
a[end + gap] = a[tmp];
}
}
}6.堆排序
详情可见博主关于堆排详解：
7.快速排序（递归和非递归写法）
任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中的所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
注意点：当快速排序接近二分(二叉树）的递归模式时，效率最高。因此引入“三数取中”优化代码：
int GetMidNumi(int* a, int left, int right) { int mid = (left + right) / 2; if (a[left] < a[mid]) { if (a[mid] < a[right]) { return mid; } else if (a[left] > a[right]) { return left; } else { return right; } } else // a[left] > a[mid] { if (a[mid] > a[right]) { return mid; } else if (a[left] < a[right]) { return left; } else { return right; } } }
1.三种排序方式
1.交换法
1.左边做key，右边先走——保证相遇位置比key小
ps：【右边先走找比key小的数，则其停止位置一定小于等于key】
2.由于左右相遇的位置一定比key小，把左边与相遇位置替换
图示：
代码：
2.挖坑法
1.先将左边第一个数据放在临时变量key中，原地形成一个坑位
2.右边先动，找小于key的数，放到坑位中，并且原地新生成一个坑位
3.当左右相遇时，将key填入最后一个坑位中
3.前后指针法（玩区间）
1.左边第一个数设为key，prev(延迟指针），cur（实时指针）
2.cur开始向右移动，找到比key小的值prev和cur同时移动
3.找到比key大的值只移动cur——保证prev和cur中间隔着一段比key大的区间
4.找到比key小的值时，交换prev下一个位置（比key大的区间）和cur位置的值——比key大的值翻到区间右边，把比key小的值翻到区间左边。
图示：
2.非递归写法（类比层序遍历用队列实现，这里用栈）
学习原因：递归的本质是不断开辟空间，当递归层数过多时可能会出现栈溢出的问题。因而引入非递归写法
实现原理：递归写法本质上是向下不断开辟空间，当达到终止条件时返回并归还空间。不采用递归的写法，即可以在原数组上直接对下标进行划分
1.入尾标，入头标
2.标记begin，end后，进行头删，并算出keyi
3.此时，原数组被分割成【begin，keyi-1】keyi【keyi+1,end】。
分别对存在的区间进行同样的操作（压栈，出栈）即可。
图示：
PS：数字表示，可视作递归的层数。而实际上没有递归。
void quicksortnonr(int*a,int left,int right)
{
ST st;
StackInit(&st);
StackPush(&st, right);//表示end的先入栈
StackPush(&st, left);
while (!StackEmpty(&st))
{
int begin = StackTop(&st);
StackPop(&st);
int end = StackTop(&st);
StackPop(&st);
//得出keyi
int keyi = Partsort3(a, begin, end);//三数取中
//【begin，keyi-1】keyi【keyi+1，end】
if (keyi + 1 < end)
{
StackPush(&st, end);//表示end的先入栈
StackPush(&st, keyi+1);
}
if (keyi -1 >begin)
{
StackPush(&st, keyi - 1);//表示end的先入栈
StackPush(&st, begin);
}
}
StackDestroy(&st);
}8.归并排序（递归和非递归写法）
1.递归写法
归并原理：两个有序数组进行比较，并尾插到新空间。
PS：结合递归后，即可细分到只剩两个数归并形成有序数组，两两合成新的有序序列，并拷贝到一块新空间（避免覆盖原数组），新空间的位置关系要与原数组对应
形象图示：
注意点：为提升效率，采用取中间数进行划分
图示：
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);
//拷贝回与原数组a相对应的位置
memcpy(a + begin,tmp + begin，sizeof(int) * (end - begin + 1));
}递归实现的逻辑：后序遍历
PS：后序遍历相关可查看博主相关博客：(62条消息) 二叉树的运用（递归)(遍历方式)(简洁.含代码,习题）_YYDsis的博客-CSDN博客
2.非递归写法（注意越界情况的分类讨论）
分析：与快排的非递归算法同理。当递归次数过多时，有可能会导致栈溢出。不妨在原数组的基础上，直接对下标对应区间范围内的数组进行归并，并拷贝回原数组。
形象图示：
注意点：有时候gap的选取会越界！
分析：本质上是不断选取【begin1，end1】【begin2，end2】
注意点：以下分析是在归并进行前，对下标对应空间进行讨论！
1.当begin1和end2和并后形成新begin1，end1时，若end1临界(begin2越界）/end1越界，则停止归并
2.当end1越界时，则对end1进行修正
形象图示：
void MergeSortNonR(int* a, int n)
{
int* tmp = (int*)malloc(sizeof(int) * n);
if (tmp == NULL)
{
perror("malloc fail\n");
return;
}
int gap = 1;
while (gap < n)
{
for (int i = 0; i < n; i += 2 * gap)
{
// [begin1,end1][begin2, end2]
int begin1 = i, end1 = i + gap - 1;
int begin2 = i + gap, end2 = i + 2 * gap - 1;//((i+gap)+(gap-1))
//printf("[%d,%d][%d,%d] ", begin1, end1,begin2,end2);
//分类讨论情况
if (end1 >= n || begin2 >= n)
{
break;
}
if (end2 >= n)
{
end2 = n - 1;//修正end2区间
}
printf("[%d,%d][%d,%d] ", begin1, end1, begin2, end2);
int j = i;
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);
}三.8种排序方式复杂度/稳定性分析
1.稳定性的概念
假定再待排序的记录序列中，存在多个具有相同关键字的记录，若经过排序，这些记录的相对次序保持不变，则称这种算法是稳定的。
2.分析
*计数排序较为特别，时间复杂度O(n)/O(range),空间复杂度为O(n)
1.简单选择排序不稳定的原因
特例：替换的数在两相同数同一边时
2.复杂度分析综述
1.希尔排序是直接插入排序基础上加了预处理。较为复杂，暂记结论。
2.直接插入排序，是取每一个数和前面所有数进行比对。无论如何都要先取，所以最好情况即有序情况即是n，最坏情况相当于一个数组的遍历，n^2。
3.快速排序当keyi每次都能取中间值时，接近二叉树，nlogn。keyi每次都取最左/右值时，即相当于一个数组的遍历，n^2。
4.归并排序，接近二叉树，nlogn。由于需要tmp新空间容纳归并后的新空间，空间复杂度为n
5.堆排序，分为堆调整（向上向下）和用删除思想堆排序两部分，根据数学计算知道后者复杂度为nlogn，即堆排整体为nlogn。
6720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
