目录
堆排序
什么是堆
- 结构满足满二叉树：除了叶子结点和最后一个叶子结点对应的结点 其余结点有左右子树
- 满足 最大堆/最小堆的堆序性
算法描述
Restore（R，root，e）：对于只有root结点不满足堆序性，利用二叉树交换父子结点，修改root 顶点的位置，使root-e之间可以满足最大堆/最小堆
先利用Restore 函数 建一个大顶堆；而后将 根结点与最后一个未排序的结点交换位置，调用Restore重建堆
- 时间复杂度：O(nlogn)
- 稳定性：不稳定
code
void Restore(int R[], int root, int e){
//重建堆，root是堆的根结点在数组R中下标, e是堆最后一个元素在R中下标
int m, j = root; //初始化，j指向堆根
while(j <= e/2){ //j最多下行至最后一个非叶结点
//比较两次，将J值
if((2*j+1<=e) && (R[2*j]<R[2*j+1])) m=2*j+1;// 最后一个非叶结点有右孩子
else m=2*j; //R[m]为R[j]的最大孩子
if(R[m]>R[j]){
swap(R[m], R[j]); //交换R[m]和R[j]
j = m; //j继续下行
}
else return;
}
}
void HeapSort(int R[],int n){ //堆排序算法
for(int i=n/2; i>=1; i--) //初始建堆
Restore(R, i, n);//改变根结点的值，来逐步构建最大堆
for(int i=n; i>=2; i--){
swap(R[1], R[i]); //R[1]和R[I]交换；让最大的元素位于堆的末端
Restore(R, 1, i-1); //重建R[1]…R[i-1]的堆
}
}
例子
代排序列：（26，5，77，1，61，11，59，15，48，19）；堆排序过程：
快速排序
基本思想：分治
➢在一个无序数组中取一个数key，每一趟排序的最终目的是：让key的左边的所有数小于key，key的右边都大于key（假设排升序）
➢分别对两个子数组重复上述方法，直到所有元素都排在相应位置上为止
单趟排序：
取数组左右两端点下标为i,j;
i向右走，遇到>key的元素停下，j向左走，遇到<key的元素停下；交换i、j对应的元素；
i、j相遇；将key与i/j对应的元素交换位置：
就实现了key的左边的所有数小于key，key的右边都大于key
- key选择得越接近数组中间值大小，快速排序算法的时间效率越高。
- 时间复杂度：O(nlogn)；最大时间复杂度：O(n^2)
- 稳定性：不稳定
优化策略
1.小数据量采用插入排序
➢当待排序元素很少时，为极小的子数组产生许多的递归调用，得不偿失，此时快速排序反而没有插入排序快。
➢递归过程中，当前处理的子数组长度小于等于某个阈值（一般取16左右）时：
✓策略1：可直接对当前子数组插入排序。
✓策略2：对当前子数组什么也不做，直接退出本层递归。待最后快速排序所有递归都退出后，再对整个大数组统一进行一次插入排序（插入排序在面对“接近有序”的序列时拥有良好的性能）。
2.随机选取基准元素
➢快速排序达最坏情况的一种原因：数组有序，每次选的基准元素（第1个元素）恰好是当前子数组的最小元素。
➢在当前子数组中随机选择一个元素作为基准元素：
➢降低最坏情况发生的概率，但无法杜绝。
➢实际应用中，采用该策略遇到最坏情况的概率极低，该策略可获得很好的性能。
3.三数取中(Median of Three)选基准元素
➢选取R[m]、R[(m+n)/2]和R[n]的中位数作为基准元素。
➢保证选出的基准元素不是子数组的最小元素，也不是最大元素，分划肯定不会分到最边上。
int Partition(int R[], int m, int n){ //对子数组R m-n进行分划
int mid=(m+n)/2;
//把三者中最大的移到R[n]的位置
if(R[mid]>R[n]) swap(R[mid],R[n]);
if(R[m]>R[n]) swap(R[m],R[n]);
//在m和mid中选一个更大的作为基准元素
if(R[m]<R[mid]) swap(R[m],R[mid]);
//正常的分划
int i=m, j=n+1,K=R[m]; // Rm为基准元素
while(i<j) {
while(++i<=n && R[i]<=K); //从左向右找第一个>K的元素
while(R[--j]>K); //从右向左找第一个<K的元素
if(i<j) swap(R[i],R[j]);
} //不断把小于K的元素换到数组左边，大于K的元素换到数组右边，直至指针i和j相遇
swap(R[m],R[j]);
return j; // <K 的元素在j左边，>k的元素在j右边
}4.尾递归优化
尾递归原理：
➢当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活动记录而不是在栈中去创建一个新的。编译器可以做到这点，因为递归调用是当前活跃期内最后一条待执行的语句，于是当这个调用返回时栈帧中并没有其他事情可做，因此也就没有保存栈帧的必要了。通过覆盖当前的栈帧而不是在其之上重新添加一个，这样所使用的栈空间就大大缩减了，这使得实际的运行效率会变得更高。
void QuickSort(int R[],int m,int n){
while(m < n){
int j=Partition(R,m,n);
if(j-m < n-j){
QuickSort(R,m,j-1); //短区间递归处理
m=j+1; //长区间循环 ；覆盖上一次的递归栈，优化空间
} //左区间短
else{
QuickSort(R,j+1,n);
n=j-1;} //右区间短
}
}
//如果每次分划都分到最边上空间复杂度甚至可降为O(1)参考： 尾递归及快排尾递归优化_Tyler_Zx的博客-CSDN博客
5.利用栈消除所有递归
短区间迭代处理，长区间压栈；
当区间长度小于阈值M时，不处理该区间，待最后对整个数组做一次插入排序
while(m < n){ //m和n为当前处理子数组的起止下标
int j = Partition(R,m,n);
int leftLen=j-m, rightLen=n-j;
//当区间长度小于阈值M时，不处理该区间，待最后对整个数组做一次插入排序
if(leftLen<M && rightLen>=M) m = j+1; //处理右区间
else if(leftLen>=M && rightLen<M) n = j-1; //处理左区间
//区间长度大于阈值M
else if(leftLen>=M && rightLen>=M){ //先处理短区间，长区间压栈
if(leftLen>rightLen) {
S.PUSH(m,j-1);
m = j+1;
}
else {
S.PUSH(j+1, n);
n = j-1;
}
}
else if(leftLen<M && rightLen<M){
if(!S.Empty()) S.POP(m,n);
else
break;
}
}
InsertSort(R,m,n);//相对有序是，直接插入的时间复杂度为0（n）6.侦测递归深度，适时转为堆排序
➢ 侦测快速排序的递归深度，当递归深度达到O(logn) 层时，强行停止递归，转而对当前处理的子数组进行堆排序。
➢ 真正使最坏情况时间复杂度降为O(nlogn)
7.三路分划(3-Way-Partition)
➢当重复元素很多时，传统快速排序效率较低。
➢修改Partition操作，将当前数组划分为三部分：小于基准元素K的元素放在左边，等于K的元素放在中间，大于K的元素在右边。
➢进一步递归时，仅对小于K的左半部分子数组和大于K的右半部分子数组进行递归排序
//出现很多重复元素
void QuickSort3way(int R[], int m, int n){
if(m>=n) return;
int i=m, j=m, k=n;//让i指向最后一个比j小的元素，让k指向最后一个比j大的元素
int pivot=R[m]; //基准元素
while (j<=k){
if (R[j] < pivot)
swap(R[j], R[i]), j++, i++;//把“红”移至左侧
else if (R[j] > pivot)
swap(R[j], R[k]), k--;//把“蓝”移至右侧.注意R[k]仍需判断，不用j++
else // R[j]==pivot
j++;
}
//（i,k）范围的元素=pivot
QuickSort3way(R, m, i-1);
QuickSort3way(R, k+1, n);
}直接插入排序
最简单的排序方法
基本操作：将一条记录插入到已排好的有序表中，从而得到一个新的、记录数量增1的有序表。
- 元素集合越接近有序，直接插入排序算法的时间效率越高。
- 时间复杂度：O(n^2)
- 最好的时间复杂度：0（n）当集合已经有序时，每次只要比较一次；
- 空间复杂度：0(1)
- 稳定性：稳定
code
void InsertSort(int a[],int l)
{
int temp;
int j;
for(int i=1;i<l;i++)
{
if(a[i]<a[i-1])//i以前的已经是有序数组
{
//把a[i]插入到数组合适的位置
temp=a[i];
for(j=i-1;j>=0&&temp<a[j];j--)
{
a[j+1]=a[j];//线性表的性质：元素顺序后移一位，腾出空间；
}
a[j+1]=temp;
}
}
} shell希尔排序
最优的小数据排序
基本操作
直接插入的一种优化； 在小数据（<50)比快速排序 要快；
思想：以数组下标为增量对元素分组；按组别进行直接插入排序；对半减小增量直到只剩一组
- 时间复杂度：O(n^1.25) //很大程度上取决于所选取分组长度序列
- 空间复杂度：0(1)
- 稳定性：不稳定
code
int ShellSort(int R[], int n){ //对R[1]…R[n]递增排序
for(int d=n/2; d>0; d/=2) //d为增量值
for(int j=d+1; j<=n; j++){
//.....R[j-3d], R[j-2d], R[j-d] 、R[j]
int i=j-d; //指针i扫描R[j-d],R[j-2d],R[j-3d]..
int K=R[j];
while (i>0 && R[i]>K){
//在本组中从右往左找第1个 R[j]的元素
R[i+d]=R[i]; i-=d; }
R[i+d]=K;
}
}归并算法
过程实例
- 最好、平均、最坏情况下 都是时间复杂度：O(nlog2n)
- 空间复杂度：0(n) //复制
- 最快的稳定性算法
优化策略
➢问题：当数据量非常小时，若仍然采用分治策略，效率不高。
➢优化策略：对于非常小的数据集，以及前几次合并动作，调用直接插入排序算法。
➢问题：Merge操作基于元素移动，当元素比较大时，赋值操作会比较费时。
➢优化策略：将数组存储改为链表存储，这样记录移动就变为指针移动了
code
void Merge(int R[],int low, int mid, int high){
/*将两个相邻的有序数组(Rlow,Rlow+1,…,Rmid)和(Rmid+1,Rmid+2,…,Rhigh)合并成一个有序数组*/
int i=low, j=mid＋1, k=0, cnt=0;
int *X=new int[high-low+1];
while(i<=mid && j<=high){
if(R[i]<=R[j])
X[k++]=R[i++];
else
X[k++]=R[j++], cnt+=mid-i+1;
}
while(i<=mid) X[k++]=R[i++]; //复制余留记录
while(j<=high) X[k++]=R[j++];
for(int k=0,i=low; i<=high; i++,k++) //将X拷贝回R
R[i]=X[k];
delete []X;
return ;
}
void MergeSort(int R[], int m, int n){
if(m < n){
int k = (m+n)/2;
MergeSort(R, m, k);
MergeSort(R, k+1, n);
Merge(R, m, k, n);
}
}选择排序
对代排序数列进行n-1次操作，每一次找到第i大（小）的树放在第i个位置
- 时间复杂度：O(n^2);最坏情况：O(N^2) 最好情况：O(N^2)
- 空间复杂度：0(1)
- 不稳定
冒泡排序
思想：不断交换序列中的反序对，直到没有反序对为止
- 时间复杂度：O(n^2);最坏情况：O(N^2) 最好情况：O(n)
- 空间复杂度：0(1)
- 稳定
C++ code
//冒泡排序
void BubbleSort(int* arr, int n)
{
int end = n;
while (end)//end-n是已经排序完毕的
{
int flag = 0;
for (int i = 1; i < end; ++i)
{
if (arr[i - 1] > arr[i])
{
int tem = arr[i];
arr[i] = arr[i - 1];
arr[i - 1] = tem;
flag = 1;
}
}
if (flag == 0)//没有发生交换，已经有序；
break;
--end;
}
}
309
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
