基本排序算法 《数据结构》严蔚敏版

    根据在排序过程中记录所占用的存储设备，将排序分为：

    1.内部排序  待排序记录存放在计算机内存中。

    2.外部排序  待排序记录数量大，内存一次不能容纳全部记录，需要对外存进行访问。

内部排序分类：

    1.插入类

    2.交换类

    3.选择类

    4.归并类

    5.分配类

一、插入排序

    按关键字的大小插入到已经排好序的一组记录中的适当位置，直到所有记录全部插入位置。按照查找插入位置的方法不同，分为直接插入排序、折半插入排序和希尔排序。

//待排序数据类型
#define MAXSIZE 20
typedef int KeyType;
typedef struct{
	KeyType key;
	InfoType otherinfo;
}RedType;
typedef struct{
	RedType r[MAXSIZE+1];       //r[0]闲置或用作哨兵
	int length;
}SqList;

1.1直接插入排序

算法描述

void InsertSort(SqList &L)
{
	for(i=2;i<=L.length;++i)                        //大循环，从第二个值开始排序
	{
		if(L.r[i].key<L.r[i-1].key)             //与i之前的已经排序好的值进行一一比较，逐个挪动
		{
			L.r[0]=L.r[i];
			L.r[i]=L.r[i-1];
			for(j=i-2;L.r[0]<L.r[j];--j)
				L.r[j+1]=L.r[j];
			L.r[j+1]=L.r[0];
		}
	}
}

1.2折半插入排序

    在查找插入位置的时候用的是查找方式是“折半查找”。

算法描述

void BInsertSort(SqList &L)
{
	for(i=2;i<=L.length;i++)
	{
		L.r[0]=L.r[i];
		low=1;high=i-1;
		while(low<high)                            //首先运用折半查找找到插入位置，最后结果总是low>high
		{
			m=(low+high)/2;
			if(L.r[0]<L.r[m]) high=m-1;
			low=m+1;
		}                           
		for(j=i-1;j>high;--j)                      //将i的值挪动到i+1上，最后将high+1的值挪动到high+2上，high+1的值为L.r[0]
		{
			L.r[j+1]=L.r[j];
		}
		L.r[high+1]=L.r[0];
	}
}

1.3希尔排序

    实质上是采用分组插入的方法。将记录分成几组，从而减少了参与直接排序的数据量，对每组进行直接插入排序，然后增加每组的数据量，重新分组，经过几次排序之后，整个序列中的记录“基本有序”，再对全体记录进行一次直接插入排序。

void ShellInsert(SqList& L,int dk)
{
	for(i=dk+1;i<=L.length;++i)
		if(L.r[i].key<L.r[i-dk].key)
		{
			L.r[0]=L.r[i];
			for(j=i-dk;j>0&&L.r[0].key<L.r[j].key;j-=dk)
				L.r[j+dk]=L.r[j];
			L.r[j+dk]=L.r[0];
		}
}

void ShellSort(SqList& L,int dt[],int t)
{
	for(k=0;k<t;++k)
		ShellInsert(L,dt[k]);
}

二、交换排序

    基本思想：两两比较待交换记录的关键字，若两个记录不符合次序要求，则进行交换。

2.1冒泡排序

    从1—n两两比较关键字，不符合次序要求则交换，第一趟结束将关键字最大的记录交换到数组最右边，第二次同理从1—(n-1)执行交换……

算法描述

void BubbleSort(SqList &L)
{
	m=L.length-1;flag=1;
	while((m>0)&&flag==0)
	{
		flag=0;
		for(j=1;j<=m;++j)
		{
			if(L.r[j].key>L.r[j+1].key)
			{
				flag=1;
				t=L.r[j];L.r[j]=L.r[j+1];L.r[j]=t;
			}
		}
		--m;
	}
}

2.2 快速排序

    在冒泡排序中每次交换两个相邻记录只能消除一个逆序，如果能通过一次交换消除多个逆序，则会大大加快排序的速度，快速排序方法中的一次交换可消除多个逆序。 

算法描述

//快速排序
int Partition(SqList& L,int low,int high)
{
	L.r[0]=L.r[low];
	pivotkey=L.r[low].key;
	while(low<high)
	{
		while(L.r[high].key>pivotkey&&low<high) --high;
		L.r[low]=L.r[high];
		while(L.r[low].key<pivotkey&&low<high) ++low;
		L.r[high]=L.r[low];
	}
	L.r[low]=L.r[0];
	return low;
}

void QSort(SqList &L,int low,int high)
{
	if(low<high)
	{
		pivoloc=Partition(L,low,high);
		QSort(L,low,pivoloc-1);
		QSort(L,pivoloc+1,high);
	}
}

void QuickSort(SqList &L)
{
	QSort(L,1,L.length);
}

三 选择排序

    基本思想：每一趟从带排序的记录中选出关键字最小的记录，按顺序放在已排好序的序列的最后。

3.1 简单选择排序

    将数组总r[1]与人r[2]-r[n]比较，找到关键字最小的记录，与r[1]交换，再从r[2]开始，与r[3]-r[n]比较，找到关键字最小的记录，与r[2]交换,……（移动次数较少，只需要一个辅助空间）

算法描述

void SelectSort(Sqlist &L)
{
	for(i=1;i<L.length;++i)
	{
		k=i;
		for(j=i+1;j<L.length;++i)
		{
			if(L.r[j].key<L.r[k].key) k=j;
		}
		if(k!=i)
		{
			t=L.r[k];L.r[k]=L.r[i];L.r[i]=t;
		}
	}
}

    选择排序的主要操作是进行关键字的比较，因此改进简单选择排序应从如何减少比较次数出发。

3.2  堆排序

    将排序记录r[1……n]看成是一颗完全二叉树的顺序存储结构。

    节点大于左子树和右子树，称为大根堆，节点小于左子树和右子树，称为小根堆。

    算法思路：1 初建堆   2 交换r[1]与r[n]，调整堆，交换r[1]与r[n-1]调整堆……

算法描述：

//调整堆
void HeapAdjust(Sqlist &L,int s,int m)
{
	rc=L.r[s];                           //将r[s]值储存起来，在调整过程中不插入
	for(j=2*s;j<=m;j*=2)
	{
		if(j<m&&L.r[j].key<L.r[j+1].key)  ++j;
		if(rc.key>=L.r[j]) break;
		L.r[s]=L.r[j];s=j;               //这里先不插入，最后插入
	}
	L.r[s]=rc.key;                       //循环结束再将r[s]值插入
}

//初建堆
void CreatHeap(Sqlist &L)
{
	n=L.length;
	for(i=n/2;i>=1;--i)
	{
		HeapAdjust(L,i,n);
	}
}

//堆排序算法
void HeapSort(Sqlist &L)
{
	CreatHeap(L);                 //初建堆
	for(i=L.length;i>=1;i--)
	{                            //不断交换并调整堆
		t=L.r[1];
		L.r[1]=L.r[i];
		L.r[i=t;
		HeapAdjust(L,1,i-1);
	}
	
}

四 归并排序

    基本思路是将两个或两个以上的有序表合并成一个有序表的过程。

算法描述：

void Merge(RedType R[],RedType &T[],int low,int mid,int high)
{
	i=low,j=mid+1,k=low;
	while(i<=mid&&j<=high)
	{
		if(R[i].key>=R[j].key) T[k++]=R[j++];
		else T[k++]=R[i++];
	}
	while(i<=mid) T[k++]=R[i++];          //将剩余的直接复制到T[k]中去
	while(j<=high) T[k++]=R[j++];
}

void Msort(RedType R[],RedType &T[],int low,int high)
{
	if(low==high) T[low]=R[low];      //分割到一组就一个元素后存入T中
	else                              //接下来两两归并排序
	{
		mid=(low+high)/2;
		Msort(R,S,low,mid);
		Msort(R,S,mid+1,high);
		Merge(S,T,low,mid,high);
	}
}

void MergeSort(Sqlist &L)
{
	Msort(L.r,L.r,1,L.length)
}