一、归并排序
递归实现===》自上向下
非递归排序===》自下向上
void Merge(int arr[],int low,int mid,int high,int tmp[])
{
int i=low,j=mid+1;
int k=-1;//记录辅助数组的下标
while(i<=mid && j<=high)
{
if(arr[i]<arr[j])
tmp[++k]=arr[i++];
else
tmp[++k]=arr[j++];
}
while(i<=mid)
tmp[++k]=arr[i++];
while(j<=high)
tmp[++k]=arr[j++];
for(int i=0;i<=k;++i)
arr[i+low]=tmp[i];
}
//递归排序属于自顶向下
void MergeSort1(int arr[],int low,int high,int tmp[])//high为数组长度减1
{
//当low==high时就递归到只有一个元素，终止递归
if(low<high)
{
int mid=low+(high-low)/2;//(low+high)/2;
MergeSort1(arr,low,mid,tmp);
MergeSort1(arr,mid+1,high,tmp);
Merge(arr,low,mid,high,tmp);
}
}
//非递归排序相当于自下向上
void MergeSort_pass(int arr[],int len,int k,int tmp[])//len为数组长度,k为步进
{
int i=0;
while(i<len-2*k+1)
{
Merge(arr,i,i+k-1,i+2*k-1,tmp);
i=i+2*k;
}
if(i<len-k+1)
Merge(arr,i,i+k-1,len-1,tmp);
}
void MergeSort2(int arr[],int len,int tmp[])
{
int k=1;
while(k<=len)
{
MergeSort_pass(arr,len,k,tmp);
k*=2;
}
}时间复杂度分析：假设问题规模为N，运行时间为T(N)
总的时间分两部分：把N分为两半时，处理大小为N/2花费时间为T(N/2)；合并花费时间与问题规模相同，为N。
总的时间为T(N)=2T(N/2)+N
等式两边同时除N ==》 (T(N))/N=(T(N/2))/(N/2)+1
令N=N/2 ==》 (T(N/2))/(N/2)=(T(N/4))/(N/4)+1
令N=N/2 ==》 (T(N/4))/(N/4)=(T(N/8))/(N/8)+1……
令N=N/2 ==》 (T(2))/2=(T(1))/1+1
所有的等式相加：(T(N))/N=T(1)+log2N(假设有从N到2有X个数，那就有2^x=N)
所以时间复杂度为：T(N)=O(Nlog2N)
稳定性：稳定
二、交换排序
（1）快速排序
递归实现 ==》先找中轴元素 再递归
非递归实现 ==》用栈实现
#include<iostream>
#include<stack>
#define SWAP(x,y) {int t;t=x;x=y;y=t;}
using namespace std;
int partition1(int arr[],int low,int high)//优化1
{
int i,j,k;
if(low<high)
{
k=arr[low];//将最左边的元素设为中轴元素
i=low;
j=high+1;
while(true)
{
while(arr[++i]<k)//向左找
{
if(i==high)
break;
}
while(arr[--j]>k)//向右找
{
if(j==low)
break;
}
if(i>=j)
break;
SWAP(arr[i],arr[j]);
}
SWAP(arr[low],arr[j]);
}
return j;
}
int partition2(int arr[],int low,int high)//优化2
{
int i,j,k;
if(low<high)
{
k=arr[(low+high)/2];//将中间元素设为中轴元素
i=low-1;
j=high+1;
while(true)
{
while(arr[++i]<k);
while(arr[--j]>k);
if(i>=j)
break;
SWAP(arr[i],arr[j]);
}
}
return j;
}
int partition3(int arr[],int low,int high)//优化3
{
int i,j,k;
k=arr[high];//将中轴元素设为最后一个元素
i=low-1;
for(j=low;j<high;++j)
{
if(arr[j]<=k)
{
i++;
SWAP(arr[i],arr[j]);
}
}
SWAP(arr[i+1],arr[high]);
return i+1;
}
void QuickSort1(int *arr,int low,int high)//递归实现
{
if(arr==NULL)
return ;
if(low<high)
{
int k=partition3(arr,low,high);
QuickSort1(arr,low,k-1);
QuickSort1(arr,k+1,high);
}
}
void QuickSort2(int *arr,int low,int high)//非递归实现
{
stack<int> st;
int k;
st.push(low);
st.push(high);
while(!st.empty())
{
high=st.top();
st.pop();
low=st.top();
st.pop();
k=partition3(arr,low,high);
if(low<k-1)
{
st.push(low);
st.push(k-1);
}
if(k+1<high)
{
st.push(k+1);
st.push(high);
}
}
}时间复杂度分析：
最坏情况：排序数组有序。每次递归后基准元素右边数组长度只比原先减1，每次分割后数组都会分割成一个大小为0和原数组
长度减一的子数组。
假设问题规模为N.
时间复杂度为分割时所花费的时间(O(N))加上左右两个子数组比较花费的时间。
T(N)=T(0)+T(N-1)+O(N)
令N=N-1 ==》 T(N-1)=T(0)+T(N-2)+O(N-1)
令N=N-1 ==》 T(N-2)=T(0)+T(N-3)+O(N-2)……
T(2)=T(0)+T(1)+O(2)
所有的推导式相加
T(N)=(N-1)T(0)+T(1)+T(2)+T(3)+……+T(N)
=N-1+1+2+3+……+N
=(N(N-1))/2+N-1
=O(N^2)
最好的情况：每次划分完毕，划分的基准在序列近乎中间的位置。
时间复杂度T(N)=2T(N/2)+O(N)
等式两边同时除N ==》 (T(N))/N=(T(N/2))/(N/2)+(O(N))/N
令N=N/2 ==》 (T(N/2))/(N/2)=(T(N/4))/(N/4)+1
令N=N/2 ==》 (T(N/4))/(N/4)=(T(N/8))/(N/8)+1
……
令N=N/2 ==》 (T(2))/2=(T(1))/1+1
所有的等式相加：(T(N))/N=T(1)+log2N(假设有从N到2有X个数，那就有2^x=N)
所以时间复杂度为：T(N)=O(Nlog2N)
稳定性：不稳定
快排之所以快是因为它高度优化的内部循环（分割），既不像归并需要辅助数组来回赋值元素，也不像堆排无法利用缓存并且有
许多无用的比较。
（2）、冒泡排序
void BubbleSort(vector<int> &vec)
{
bool mark=false;
for(int i=0;i<(vec.size()-1);++i)
{
//第i+1趟要比较的N-i-1次
for(int j=0;j<(vec.size()-1-i);++j)
{
if(vec[j]>vec[j+1])
{
SWAP(vec[j],vec[j+1]);
mark=true;
}
}
if(mark==false)
break;
}
}时间复杂度分析：假设问题规模为N
需要比较N-1趟，
第一趟比较N-1次
第二趟比较N-2次……
第N-1趟比较1次
总共比较次数：1+2+3+……+N-1=(N(N-1))/2
时间复杂度为O(n^2)
稳定性： 稳定三、选择排序
（1）、堆排序
void Sink(int arr[],int len,int rootindex)//下沉法进行堆调整;小堆根
{
int root=arr[rootindex];
int childindex=rootindex*2+1;//初始化为左孩子的下标
while(childindex<len)//调整没有结束
{
if(childindex!=len-1 && arr[childindex]>arr[childindex+1])
{
childindex++;
}
if(root>arr[childindex])//*1
{
arr[rootindex]=arr[childindex];
rootindex=childindex;
childindex=rootindex*2+1;
}
else
break;
}
arr[rootindex]=root;//*2
/*
当实现元素交换时只进行子节点元素上移，较小的父节点是通过*2这一句实现的
*/
}
void HeepSort(int arr[],int len)
{
if(len<2)
return ;
for(int rootindex=(len-2)/2;rootindex>=0;--rootindex)
Sink(arr,len,rootindex);
for(int i=len-1;i>=0;--i)
{
SWAP(arr[0],arr[i]);
Sink(arr,i,0);
}
}时间复杂度分析：假设问题规模大小为N
时间复杂度为建堆花费时间加上“删除”最小元素花费时间之和。
建堆时间：堆中每个节点向下交换所花费的时间之和。堆中的节点最多交换到叶子节点，也既节点向下交换与所在高度有关系。
i.N个元素的堆，高度为h的节点最多有N/(2^(h+1))
ii.N个元素的堆的高度为floor(log2N)(log2N向下取整)
设高度为h的节点向下交换的代价为O(h)
建堆的时间复杂度为不同高度的每个节点向下交换的代价之和T1=(N/(2^2)+N/(2^3)+……+N/(2^(h+1)))*O(h)其中h={1,2,3……log2N)}=O(n)
“删除”最小元素花费时间:需要删除N-1次，删除包含两步：交换和堆调整。交换操作代价为常数，可忽略。T2=(N-1)*logN
故实时间复杂度为O(Nlog2N)
最后两时间相加堆排序的时间复杂度为O(Nlog2N)
稳定性：不稳定
（2）、直接选择排序
void Selete_Sort(vector<int> &vec)
{
int tmp;
int len=vec.size();
for(int i=0;i<len-1;++i)
{
int minindex=i;
for(int j=i+1;j<len;++j)
{
if(vec[j]<vec[minindex])
minindex=j;
}
tmp=vec[minindex];
vec[minindex]=vec[i];
vec[i]=tmp;
}
}时间复杂度分析：假设问题规模为N
时间复杂度：需要选择N-1次，每次选择需要比较N-1次
T(N)=1+2+3+……+N-1=O(N2)
稳定性： 不稳定四、插入排序
（1）、希尔排序
void Shell(vector<int> &vec,int gap_len)
{
int len=vec.size();
int j;
int tmp;
for(int i=gap_len;i<len;i++)
{
tmp=vec[i];
for(j=i-gap_len;j>=0 && vec[j]>tmp;j-=gap_len)
{
vec[j+gap_len]=vec[j];
}
vec[j+gap_len]=tmp;
}
}
void ShellSort(vector<int> &vec)
{
Shell(vec,3);//多次分组，3为分组步进
Shell(vec,1);
}时间复杂度：时间复杂度为O(N^1.3)，实际时间复杂度为O(log2N)~O(N^2)
稳定性：不稳定
（2）、直接插入排序
void InsertSort(vector<int> &vec)
{
int tmp,int j;
int len=vec.size();
for(int i=1;i<len;++i)
{
tmp=vec[i];
for(j=i-1;j>=0 && vec[j]>tmp;--j)
vec[j+1]=vec[j];
vec[j+1]=tmp;
}
}时间复杂度分析：假设问题规模为N
需要插入N-1次，每次插入需要比较N-1次
T(N)=1+2+3+……+N-1=(N(N-1))/2
时间复杂度为O(N^2)
稳定性：稳定
五、总结
1、平均性能为O(N^2)的有：直接插入排序、选择排序、冒泡排序。当数据量较小时，这三种排序差不多；当数据量较大时，冒泡排序时间代价最高。
2、平均性能为O(Nlog2N)的有：快速排序、归并排序、希尔排序、堆排序。当数据量大时，这三种排序较好；当数据是随机的时，快排平均时间最短；但在基本有序的情况下，快排反而不好；若要求稳定，则选归并。
3、若数据初始基本有序（正序），选直接插入或者冒泡或者随机的快排。
477
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
