数据结构第八章——排序,考研必备

数据结构第八章——排序

什么是排序？

排序：将一组杂乱无章的数据按一定规律顺序依次排列起来

存储结构——记录序列以顺序表存储

#define MAXSIZE 20//设记录不超过20个
typedef int KeyType;//设关键字为整型量（int）
typedef struct{
	KeyType key;//关键字
	InfoType otherinfo;//其他数据项
}RedType;
typedef struct{
	RedType r[MAXSIZE + 1];//存储顺序表的向量
	int length;//
}

插入排序

基本思想：每步将一个待排序的对象，按其关键码大小，插入到前面已经排好序的一组对象的适当位置上，直到对象全部插入为止。

有序插入：在有序序列中插入一个元素，保持序列有序，有序长度不断增加

直接插入排序

void InsertSort(SqList &L){
	int i, j;
	for(j = 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(int i = 2; i < L.length; ++i){//依次插入第2~n个元素
		L.r[0] = L.r[i];//当前插入元素存到哨兵位置
		int	low = 1;
		int high = i - 1;//采用二分查找法查找插入位置
		while(low <= high){
		int	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 dlta[], int t){
	//按增量序列dlta[0,……，t-1]对顺序表L作希尔排序
	for(int k = 0; k < t; ++k){
		ShellInsert(L,dlta[k]);//一趟增量为dlta[k]的插入排序
	}
}
void ShellInsert(SqList &L, int dk){
	for(int i = dk+1; i = L.length;i++){
		if(r[i].key < r[i-dk].key){
			r[0] = r[i];
			for(j = dk; j > 0&& r[0].key < r[j].key; j= j-dk)
				r[j+dk] = r[j];
			r[j+dk] = r[0];
		}
	}
}

希尔排序是不稳定的排序

冒泡排序

基本思想：每趟不断将记录两两比较，并按“前小后大的”规则交换

void bubble_sort(SqList &L){
	int m, i, j;
	RedType x;//交换时临时存储
	for(m = 1; m < n - 1; 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;
			}
		}
	}
}

优点：每趟结束时，不仅能挤出一个最大值到最后面位置，还能同时部分理顺其他元素

//改进的冒泡排序算法
void bubble_sort(SqList &L){
	int m, i, j;
	RedType x;//flag作为是否有交换的标记
	for(m = 1; m < n -1 && flag == 1; m++){
		flag = 0;
		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;
			}
			
		}
	}
}

快速排序

基本思想：任取一个元素为中心，所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个子表。对各个子表重新选择中心元素并依次规则调整，知道每个子表的元素只剩一个。

1. 每一趟的子表的形成是采用哦才能够两头向中间交替式逼近法
2. 由于每趟中对各子表的操作都相似，可采用递归算法

void Qsort(SqList &L, int low, int high){
	if(low < high){
		pivotloc = Partition(L,low, high);
		//讲L.r[low...high]一分为二，pivotloc为枢轴元素拍好学的位置
		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;
}

简单选择排序

基本思想：再待排序的数据中选出最大（小）的元素放在其最终的位置

基本操作：

1. 首先通过n-1此关键字比较，从n个记录中找出关键字最小的记录，讲它与第一个记录交换
2. 再通过n-2次比较，从剩余的n-1个记录中找出关键字次笑的记录，讲它与第二个记录交换
3. 重复上述步骤，共进行n-1躺排序后，排序结束

void SelectSort(SqList &L){
	for(int i = 1; i < L.length;++i){
		int	k = i;
		for(int j = i+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];//交换
	}
}

简单选择排序是不稳定排序

选择排序——堆排序

堆排序：若再输出堆顶的最小值（最大值）后，使得剩余N-1个元素的序列重新又建成一个堆，则得到n个元素的次小值（次大值）……如此反复，便能得到一个有序序列，这个过程称之为堆排序

如何在输出堆顶元素后，调整为一个新的堆

小根堆：

1. 输出堆顶元素之后，以堆中最后一个元素替代之；
2. 然后将根结点值与左右子树的根结点值进行比较，并与其中小值进行交换
3. 重复上述操作，直至叶子结点，将得到新的堆，成这个从堆顶至叶子调整过程为“筛选”

void HeapAdjust(elem R[],int s, int m){
	//已知R[S..m]中记录的关键字除R[s]之外均满足堆的定义，本函数调整R[s]的关键字，使R[s..m]成为一个大根堆
	rc = R[s];
	for(j = 2 * s; j <= m; j*=2){
		if(j < m && R[j] < R[j + 1]) ++j;//j为key较大的记录的下标
		if(rc > R[j]) break;
		R[s] = R[j]; s= j;//rc应插入在位置s上
	}
	R[s] = rc;
}

堆的建立

单结点的二叉树是堆

在完全二叉树中所有叶子结点为根的子树是堆

从最后一个非叶子结点开始，以此向前调整

1. 调整第n/2个元素开始，将以该元素上为根的二叉树调整为堆
2. 将以序号为n/2-1的结点为根的二叉树调整为堆
3. 再将序号为n/2-2的结点为根的二叉树调整为堆
4. 再将以序号为n/2-3的结点为根的二叉树调整为堆

void HeapSort(elem R[]){
	int i;
	for(i = n / 2; i >= 1; i--){
		HeapAdjust(R,i,n);
	}
	for(i = n; i > 1; i--){
		Swap(R[1],R[i]);
		HeapAdjust(R,1,i-1);
	}
}

归并排序

基本思想：将两个或两个以上的有序序列归并为一个有序序列