本文详细介绍了八种经典的排序算法，包括插入排序、选择排序、冒泡排序、快速排序、堆排序、希尔排序、折半插入排序及二路归并排序。每种算法均附有实现代码，便于读者理解和应用。
1）插入排序
每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序，直到待排序数据元素全部插入完为止
//假定a[0...i-1]有序，a[i]为待插入元素
void insertSort(int a[],int n)
{
int i,j,k;
for(i=1;i!=n;++i)
{
//为a[i]在前面的a[0...i-1]有序区间中找一个合适的位置
for(j=i-1;j>=0;--j)
{
if(a[j]<a[i])//找到第一个比a[i]小的元素的位置
break;
}
if(j!=i-1)//需要进行后移的情况
{
int temp=a[i];
for(k=i-1;k>j;k--)
a[k+1]=a[k];
a[j+1]=temp;
}
}
}
//将搜索和数据后移这两个步骤合并
void insertSort2(int a[],int n)
{
int i,j;
for(i=1;i<n;++i)
{
if(a[i]<a[i-1])
{
int temp=a[i];
for(j=i-1;j>=0 && a[j]>temp;j--)
a[j+1]=a[j];
a[j+1]=temp;
}
}
}
//如果将数据插入换成数据交换
void insertSort3(int a[],int n)
{
int i,j;
for(i=1;i<n;++i)
for(j=i-1;j>=0&&a[j]>a[j+1];--j)
swap(a[j],a[j+1]);
}2）选择排序
每一趟从待排序的数据元素中选出最小（大）的一个元素，顺序放在已排好序列之后，直到全部排序的元素排完（和初始序列没关系）
//直接选择排序
void selectSort(int a[],int n)
{
int i,j,minIndex;
for(i=0;i<n;i++)
{
minIndex=i;
for(j=i+1;j<n;j++)
{
if(a[j]<a[minIndex])
minIndex=j;
}
swap(a[i],a[minIndex]);
}
}
inline void swap(int &a,int &b)
{
int c=a;
a=b;
b=c;
}3）冒泡排序
两两比较待排序数据元素的大小，发现两个数据元素次序相反就交换，直到一趟中不再发生交换，排序结束
void bubbleSort(int a[],int n)
{
for(int i=0;i<n;++i)
{
for(int j=1;j<n-i;++j)
if(a[j-1]>a[j])
swap(a[j-1],a[j]);
}
} void bubbleSort(int a[],int n)
{
bool flag=true;
int k=n;
while(flag)
{
flag=false;
for(int j=1;j<k;++j)
{
if(a[j-1]>a[j])
{
swap(a[j-1],a[j]);
flag=true;
}
}
k--;
}
} 4）快速排序
在当前无序区R[1..H]任取一个数据元素作为比较的基准(记为X)，用此基准将当前的无序区划分为两个较小的无序区R[1..I-1],R[I+1,H]，且左边无序区中的数据元素都小于等于X，右边的无序区中的数据元素都大于基准元素。而基准X则位于最终排序的位置上。当R[1..I-1]和R[I+1,H]都非空时，再对 它们进行如上划分，直至所有数据区中的元素都排序完全。（待排序列越无序，算法效率越高）
int adjustArray(int s[],int l,int r)
{
int i=l,j=r;
int x=s[l];
while(i<j)
{
//从右向左找小于x的数来填s[i]
while(i<j&&s[j]>=x)
j--;
if(i<j)//要时刻注意边界
{
s[i]=s[j];
i++;
}
//从左向右找大于或等于x的数来填s[j]
while(i<j&&s[i]<x)
i++;
if(i<j)
{
s[j]=s[i];
j--;
}
}
s[i]=x;
return i;
}
//分治法的代码
void quick_sort1(int s[],int l,int r)
{
if(l<r)
{
int i=adjustArray(s,l,r);
quick_sort1(s,l,i-1);
quick_sort1(s,i+1,r);
}
}
//整理之后
void quick_sort(int s[],int l,int r)
{
if(l<r)
{
int i=l,j=r,x=s[l];
while(i<j)
{
while(i<j&&s[j]>=x)
j--;
if(i<j)
s[i++]=s[j];
while(i<j&&s[i]<x)
i++;
if(i<j)
s[j--]=s[i];
}
s[i]=x;
quick_sort(s,l,i-1);
quick_sort(s,i+1,r);
}
}
int main()
{
int arr[10]={12,3,5,-1,4,8,3,2,1,0};
quick_sort(arr,0,9);
for(int i=0;i!=10;i++)
cout<<arr[i]<<" ";
cout<<endl;
return 0;
}快速排序每次将待排序数组分为两个部分，在理想状况下，每一次都将待排序数组划分成等长两个部分，则需要logn次划分。
在最坏的情况下，即数组有序或基本有序的情况下，每次划分只能减少一个元素，快速排序将不幸退化为冒泡排序，所以快速排序时间下界为O(nlogn)上界为O(n^2)
快速排序的平均时间复杂度为O(nlogn)
排序过程中只会花常数级的空间。空间复杂度为O(1)
5）堆排序
推排序是一树形选择排序，在排序过程中，将R[1..N]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲节点和孩子节点之间的内在联系选择最小的元素。每一趟排序的基本操作是：将当前无序区调整为一个大顶堆，选取关键字最大的堆顶记录，将它和无序区中最后一个记录交换
堆排序的最坏时间为O(log2n)，这是它相对于快速排序的最大优点，同时它的空间复杂度为O(1)，在所有时间复杂度为O(nlog2n)的排序中也是最小的。
6）希尔排序
希尔排序又叫缩小增量排序，其本质还是插入排序，只不过将待排序的序列按某种规则分成几个子序列，分别对这几个子序列进行直接插入排序。最后以增量1分割整个序列，其实就是最整个序列进行一趟直接插入排序，从而完成整个希尔排序。
void shellSort(int a[],int n)
{
int i,j,gap;
//步长
for(gap=n/2;gap>0;gap/=2)
{
for(i=0;i<gap;++i) //这里就是直接插入排序了，只不过每次排序的位置都是和gap有关的
{
for(j=i+gap;j<n;j+=gap)
{
int temp=a[j];
int k=j-gap;
while(k>=0&&a[k]>temp)
{
a[k+gap]=a[k];
k-=gap;
}
a[k+gap]=temp;
}
}
}
}7）折半插入排序
折半插入排序的思想和直接插入排序一样，区别在于寻找插入位置的方式不同。从直接插入排序的流程中可以看出，每次都是在一个已经有序的序列中插入一个新的记录，所以在这个有序序列中寻找插入位置，就可以用折半查找的方式进行。
8）二路归并排序
归并排序采用分治法
将原始序列看成N个只含有一个元素的子序列，显然这些子序列都是有序的。两两归并，形成若干二元组，再将这个序列看成若干个二元组子序列。继续两两归并，形成若干有序四元组.......不停的这样归并，最后会使整个序列变得有序。
首先考虑将两个序列合并
//合并数列的效率是比较高的，可以达到O(n)
void mergeArray(int a[],int n,int b[],int m,int c[])
{
int i,j,k;
i=j=k=0;
while(i<n&&j<m)
{
if(a[i]<b[m])
c[k++]=a[i++];
else
c[k++]=b[j++];
}
while(i<n)
c[k++]=a[i++];
while(j<m)
c[k++]=b[j++];
}先通过递归分解数列，再合并数列就完成了归并排序。
//将两个有序数列a[first...mid]和a[mid...last]合并
void mergearray(int a[],int first,int mid,int last, int temp[])
{
int i=first,j=mid+1;
int m=mid,n=last;
int k=0;
while(i<=m&&j<=n)
{
if(a[i]<=a[j])
temp[k++]=a[i++];
else
temp[k++]=a[j++];
}
while(i<=m)
temp[k++]=a[i++];
while(j<=n)
temp[k++]=a[j++];
for(i=0;i<k;i++)
a[first+i]=temp[i];
}
void mergesort(int a[],int first, int last, int temp[])
{
if(first<last)
{
int mid=(first+last)/2;
mergesort(a,first,mid,temp);
mergesort(a,mid+1,last,temp);
mergearray(a,first,mid,last,temp);
}
}
bool MergeSort(int a[],int n)
{
int *p=new int[n];
if(p==NULL)
return false;
mergesort(a,0,n-1,p);
delete[] p;
return true;
}
--------------------------------------------------------------------------------------------------------------------------------------------------
时间复杂度：
平均时间：快速排序，希尔排序，归并排序和堆排序为O(nlog2n)，其它都是O(n*n)
最坏时间：快速排序为O(n*n)，其它都和平均时间相同
空间复杂度：
快速排序O(log2n)，归并排序O(n)，基数排序O(rd)，其它都是O(1)
稳定性：
快速排序，简单选择排序，希尔排序，堆排序这四种是不稳定的，其它都是稳定的
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
