一、归并排序
递归实现===》自上向下
非递归排序===》自下向上
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、若数据初始基本有序(正序),选直接插入或者冒泡或者随机的快排。