【数据结构与算法】排序

插入排序
交换排序
选择排序
归并排序
基数排序
外部排序

插入排序

顺序法定位插入位置→直接插入排序
二分法定位插入位置→二分插入排序
缩小增量多遍插入排序→希尔排序

• 直接插入排序
  1.复制插入元素（也可以增加哨兵）
  2.记录后移，查找插入位置
  3.插入到正确位置

void InsertSort(SqList &L){
	int i j;
	for(i=2;i<=L.length;++i){
		if(L.r[i].key<l.r[i-1].key){ //若“<”,需将L.r[i]插入有序子表
			L.r[0]=L.r[i];    //复制为哨兵
			for(j=i-1;L.r[0].key<L.r[j].key;--j){
				L.r[j+1]=L.r[j];     //记录后移
				}
				L.r[j+1]=L.r[0];     //插入到正确位置
			}
		}
			

• 折半插入排序

void BInsertSort(SqList &L){
	for(i=2; i<=L.length;++i){ //依次插入第2~第n个元素
		L.r[0]=L.r[i];     //当前插入元素存到“哨兵”位置
		low=1;high=i-1;   //采用二分查找法查找插入位置
		while(low<=high){
			mid=(low+high)/2;
			if(L.r[0].key<L.r[mid].key) high=mid-1;
			else low=mid+1;
		}  //循环结束，high+1则为插入位置
		for(j=i-1;j>=high+1;--j) L.r[j+1]=L.r[j]   //移动元素
		L.r[high+1]=L.r[0];     //插入到正确位置
		}
	}

折半插入排序减少了比较次数，但并没有减少移动次数
平均性能优于直接插入排序

• 希尔排序

void ShellSort(Sqlist &L, int delta[], int t){
	//按增量序列delta[0...t-1]对顺序表L作希尔排序
	for(k=0;k<t;++k)
		ShellInsert(L,dlta[k]);   //一趟增量为dlta[k]的插入排序
	}

void ShellInsert(SqList &L,int dk){
	//对顺序表L进行一趟增量为dk的Shell排序，dk为步长因子
	for(r[i].key<r[i-dk].key){
		r[0]=r[i];
		for(j=i-dk;j>0&&(r[0].key<r[j].key);j=j-dk)
			r[j+dk]=r[j];
		r[j+dk]=r[0];
	}
}
	

交换排序

• 冒泡排序
  n个记录，总共需要n-1趟
  第m趟需要比较n-m次

void bubble_sort(SqList &L){   //冒泡排序算法
	int m,i,j;    RedType x;    //交换时临时存储
	for(m=1;m<=n-1;m++){  //总共需要m趟
		for(j=1;j<=n-m;j++)
			if(L.r[j].key>L.r[j+1].key){  //发生逆序
				x=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=x;   //交换
				} //endif
			}//for
		}

如果发现某一趟没有发生移动，则证明已经排好序了。后面几趟不需要了。故以此作为改进。

void bubble_sort(SqList &L){  //改进的冒泡排序算法
	int m,i,j; flag=1   RedType x;    //交换时临时存储
	for(m=1;m<=n-1&&flag==1;m++){ 
	    flag=0;        //总共需要m趟
		for(j=1;j<=n-m;j++)
			if(L.r[j].key>L.r[j+1].key){  //发生逆序
				flag=1; //发生交换，flag置为1，若本趟没有发生交换，flag为0
				x=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=x;   //交换
				} //endif
			}//for
		}

• 快速排序

void QSort(SqList &L,int low,int high){ //对顺序表L快速排序
	if(low<high){  //长度大于1
		pivotloc=Pattition(L,low,high);
		//将L.r[low..high]一分为二，pivotlov为枢轴元素排好序的位置
		QSort(L,low,pivotloc-1);  //对低子表递归排序
		QSort(L,pivotloc+1,high);  //对高子表递归排序
	}
	}

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

• 简单排序算法

void SelectSort(SqList &K){
	for(i=1;i<L.length;++i){
		k=i;
		for(j+1;j<=L.length;j++)
			if(L.r[j].key<L.r[k].key) k=j; //记录最小值位置
		if(k!=i) L.r[i]←→L.r[k];  //交换
		}
	}

• 堆排序
• 归并排序
• 基数排序