各种排序算法总结

1：合并排序

合并排序算法使用分治策略实现对n个元素进行排序的算法。其基本思想是：将待排序元素分成大小大致相同的两个子集合，分别对两个子集合进行排序，最后总将排好序的子集合合并成所要求的排好序的集合。算法描述如下：

void MergeSort(Typr a[],int left,int right)

{

if(left<right){ //至少有两个元素

int i=(left+right)/2; //取中点

MergeSort(a,left,i);

MergeSort(a.i+1,right);

Merge(a,b,left,i,right); //合并到数组b

Copy(a,b,left,right); //复制回数组a

}

}

void Merge(Type c[],Type d[],int l,int m,int r)

{

int i=l,j=m+1,k=1;

while((i<=m)&&(j<=r))

{

if(c[i]<=c[j]) d[k++]=c[i++];

else d[k++]=c[j++];

}

if(i>m) for(int q=j;q<=r;q++) d[k++]=c[q];

else for(int q=i;q<=m;q++) d[k++]=c[q];

}

时间复杂度：O(nlgn)

2：插入排序

插入排序比较简单，算法描述如下：

for j=2 to A.length

key=A[i];

i=j-1;

while i>0 and A[i]>k

A[i+1]=A[i];

i--;

A[i+1]=key;

时间复杂度：O(n²)

3：冒泡排序: O(n²)

每次相邻的两个数据进行比较，大的向下沉，小的向上升，像水中的气泡一样。 1 for(int i=0;i<n;i++)

for(int i=0;i<n;i++)
{
int k=i;
for(int j=i+1;j<n;j++)
{
if(A[j]<A[k])   k=j;
}
swap(A[i],A[k]);
}

4：选择排序：O(n²)

for(int i=0;in<n;i++)
{
for(int j=i+1;j<n;j++)
{
if(A[i]>A[j])     swap(A[i],A[j]);
}

}

5：堆排序：①把数组调整成一个最大堆 （从A[n/2]...1进行调整） A[i]的做节点是A[2i],右节点是A[2i+1]

②每次把对顶元素A[0]和A
进行交换，A[0]放到了正确的位置，然后n--,调整堆使其仍然成为一个最大堆重复②的操作直到得到结果

时间复杂度：O(nlgn)

6:快速排序：就不说什么了,时间复杂度O(nlgn)

void QuickSort(Type a[],int p,int r)
{
if(p<r)
{
int q=Partition(a,p,r);
QuickSort(a,p,q-1);
QuickSort(aa,q+1,r);
}
}

int Partition(Type a[],int p,int r)
{
int i=p,j=r+1;
Type x=a[p];
while(true)
{
while(a[++i]<x&&i<r);
while(a[--j]>x);
if(i>=j)     break;
Swap(a[i],a[j]);
}
a[p]=a[j];
a[j]=x;
return j;
}

////线性时间排序

计数排序、计数排序、桶排序

计数排序：假设每个输入元素都是在0到k区间内的一个整数，当k=O(n)时，排序运行的时间Θ（n）

基数排序基本思想：对每一个输入元素x,确定小于x的元素的个数。利用这一信息，就可以直接把x放到它在输出数组中的位置上了。

伪代码：假设输入时一个数组A[1..n],A.length=n。我们需要两个数组：B[1..n]存放排序的输出，C[0..k]提供临时存储空间。

for i=0 to k //c的值全置0

c[i]=0;

for j=1 to A.length //c[i]等于i的元素的个数

c[A[j]]=C[A[j]]+1

for i=1 to k //c[i]记录有多少元素是小于等于i的

c[i]=c[i]+c[i-1]

for j=A.length downto 1

B[c[A[j]]]=A[j]

c[A[j]]=C[A[j]]-1

桶排序：假设输入数据服从均匀分布，平均情况下它的时间代价为O(n)

伪代码：假设输入是一个含有n个元素的数组A,切每个A[i]满足0<=A[i]<1一个临时数组B[0..n-1]来存放链表，并假设存在一种用于维护这些链表的机制

n=A.length
let  B[0..n-1] be a new array
for i=0 to n-1
make B[i]an empty list          //各个桶初始化为空
for i=1 to n
insert A[i] into list B[nA[i]]         //把数据插入到各个桶中
for i=0 to n-1
sort list B[i] with  insertion sort  //用插入排序对桶中的节点进行排序
concatenate  lists B[0],B[1]...B[n-1]together in order    //链接各个桶中的元素