Heap_Sort,Shell_Sort and Quick_Sort

介绍三种排序，堆排序、希尔排序和快速排序。

首先是堆排序：一个有n个记录的线性序列{R1,R2,R3,....Rn},其关键字序列{K1,K2,....,Kn}

                         满足{Ki<=K2i Ki<=K(2i+1)}或者是大于等于 那么就称之为堆。如果用一课完全二叉

                         来表示堆的话，就是说该树中的非叶子结点的值均不大于(或不小于)其左右两个分支结点的值。

堆排序有两个关键步骤: (1)构造堆，将一个无序序列初始化为一个堆；
                                      (2)调整堆，在输出了堆的根节点之后，调整剩余元素成为一个新的堆.

下面是代码      

#include<iostream>
using namespace std;

void HeapSort(int a[],int n); //堆排序
void HeapAdjust(int a[],int s,int m); //调整堆

int main()
{
	int a[8]={20,25,18,33,58,95,46,20};
	int i;
	HeapSort(a,8);
	for(i=7;i>=0;i--)
		cout<<a[i]<<"  ";
	cout<<endl;
	return 0;
}
							  /*调整堆*/
		/*---------------------------------------------------------
		/ 假设在输出根节点之后,以最后一个元素代替它。此时根节      
		/ 点的左右子树均为堆， 则只需要自上而下进行调整即可。      
		/ 首先将它和左右子树相比较，如果根节点比它两个子结点       
		/ 的值都小，那么就是堆了不用调整；否则，让根结点和其中     
		/ 较小的结点值互换，先让根节点满足堆的定义。可能因为交换， 
		/ 使得交换以后的结点的子树不满足堆的性质，则继续向下调整。 
		/---------------------------------------------------------*/

void HeapAdjust(int a[],int s,int m)
{
	int temp=a[s];
	for(int j=2*s+1;j<=m;j*=2)
	{
		if(j<m && a[j]>a[j+1])
			j++;             //j指向两个子结点中较小的一个
		if(!(temp>a[j]))
			break;
		a[s]=a[j];
		s=j;
	}
	a[s]=temp;     
}
				            /*构造堆*/
		/*-----------------------------------------------------------------
		/ 为构造堆，可以在已经是堆的两个自序列上加上它们的根节点，并进行   
		/ 必要的调整使之成为更大的堆。加上根节点以后，可能不满足堆的定义  
		/ 则可以用前面的调整堆的算法进行调整，使之称为堆。所以从一个无序   
		/ 序列构造堆的过程就是反复调整的过程。将n个待排序的关键字序列看为  
		/ 一棵完全二叉树,则最后一个非叶子结点为第(int)[n/2]个元素。首先，  
		/ 将n个叶子结点看成是n个堆，然后从第int[n/2]个结点开始，依次将第  
		/ [n/2],[n/2]-1,....,第1个结点按照堆的定义逐一加到它们的子结点上。 
		/ 直到最后建成一个完全的堆。                                       
		/-----------------------------------------------------------------*/

void HeapSort(int a[],int n)
{
	for(int i=(n-1)/2;i>=0;i--) //构造堆
		HeapAdjust(a,i,n-1);
	for(i=n-1;i>=0;i--)  //进行堆排序,将最小值放在序列的最后
	{
		int temp=a[0];
		a[0]=a[i];
		a[i]=temp;
		HeapAdjust(a,0,i-1);
	}
}

下面是输出结果：

18  20  20  25  33  46  58  95
Press any key to continue

按照数组的初态生成的堆和调整后的堆分别如下所示：

 

下面是希尔排序：

希尔排序的时间复杂度不好估量，gap的选取也没有定论，gap＝[gap/2]的程序较好写。

#include<iostream>
#include<time.h>
using namespace std;

void Shell_Sort(int a[],int n);

int main()
{
	int i,m;
	cout<<"测试50000个随机数"<<endl;
	int p[50000]={0};

	srand((unsigned int)time(0));
	for(i=0;i<50000;i++)
		p[i]=rand()%10000;
	clock_t star=clock(),end(0);
	Shell_Sort(p,50000);

	end=clock();
	cout<<"用时"<<double(end-star)<<"ms"<<endl;
	cout<<endl;
	return 0;
}

void Shell_Sort(int a[],int n)
{
	for(int gap=n/2;gap;gap=gap/2)
	{

		for(int i=gap;i<n;i++)
		{
			int temp=a[i];
			for(int j=i;j>=gap && temp<a[j-gap];j-=gap)
				a[j]=a[j-gap];
			a[j]=temp;
		}
	}
}

测试5W个随机数的排序时间是20ms左右。

最后是快速排序：

#include<iostream>
#include<time.h>
using namespace std;
void QuickSort(int s[],int low,int high);
int main()
{
	int a[10000],i;
	srand((unsigned int)time(0));
	for(i=0;i<10000;i++)
		a[i]=rand()%2000;
	clock_t star=clock(),end(0);
	QuickSort(a,0,9999);
	for(i=0;i<10000;i++)
	{
		cout<<a[i]<<" ";
		if((i+1)%10==0)
			cout<<endl;
	}
	cout<<endl;
	end=clock();
	cout<<"用时"<<double(end-star)<<"ms"<<endl;
	return 0;
}

void QuickSort(int a[],int low,int high)
{
	int i=low,j=high;
	int temp=a[low];
	while(i<j)
	{
		while(i<j && a[j]>=temp)
			j--;
		if(i<j)
			a[i]=a[j];
		while(i<j && a[i]<=temp)
			i++;
		if(i<j)
			a[j]=a[i];
	}
	a[i]=temp;
	if(low<high)
	{
		QuickSort(a,low,i-1);
		QuickSort(a,i+1,high);
	}
}

测试5W随机数，时间10ms左右。