《数据结构（C语言版）第二版》第八章-排序（8.3-交换排序、8.4-选择排序）

Flerken1012024-09-09 14:01

8.3 交换排序

8.3.1 冒泡排序

【算法特点】

(1) 稳定排序。

(2) 可用于链式存储结构。

(3) 移动记录次数较多，算法平均时间性能比直接插入排序差。当初始记录无序，n较大时， 此算法不宜采用。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 26

typedef int KeyType;
typedef char InfoType;

typedef struct
{
	KeyType key;
	InfoType otherinfo;
}RedType;

typedef struct
{
	RedType r[MAXSIZE + 1];  //r[O]闲置或用做哨兵单元
	int length;
}SqList;

void CreateSqList(SqList& L);
void BubbleSort(SqList& L);
void printSqList(SqList L);

int main()
{
	SqList L = { {0},0 };

	CreateSqList(L);
	BubbleSort(L);
	printSqList(L);

	return 0;
}


void CreateSqList(SqList& L)
{
	int i = 0;

	printf("请输入顺序表的元素个数：");
	scanf_s(" %d", &L.length);

	for (i = 1; i <= L.length; i++)
	{
		printf("请输入第%d个关键字：", i);
		scanf_s(" %d", &L.r[i].key);
	}
}

//算法8.4 冒泡排序
void BubbleSort(SqList& L)
{
	int m = L.length - 1;
	int flag = 1;  //flag用来标记某一趟排序是否发生交换
	int j = 0;
	RedType temp = { 0,'\0' };

	while (m > 0 && flag == 1)
	{
		flag = 0;  //flag置为0, 如果本趟排序没有发生交换，则不会执行下一趟排序

		//第 L.length - m 趟冒泡排序
		for (j = 1; j <= m; j++)  //j最大值只能取到m.每趟冒泡排序针对的是从L.r[1]到L.r[m+1]，将其中最大的，放到最后一个位置，即L.r[m+1]处
		{
			if (L.r[j].key > L.r[j + 1].key) //当L.r[j].key == L.r[j+1].key时，不会发生交换，保证了本冒泡排序的稳定性。
			{
				flag = 1;  //flag置为1, 表示本趟排序发生了交换

				//交换前后两个记录
				temp = L.r[j];
				L.r[j] = L.r[j + 1];
				L.r[j + 1] = temp;
			}
		}
		//序列中从L.r[m + 1]到L.r[L.length]处的元素都有序了

		--m; 
		//【m自减之后】下一次冒泡排序针对的仍然是从L.r[1]到L.r[m+1]的关键字
	}
}

void printSqList(SqList L)
{
	int i = 0;

	printf("\n\n排序后的序列为：");
	for (i = 1; i <= L.length; i++)
	{
		printf("\nr[%d].key = %d", i, L.r[i].key);
	}
}


8.3.2 快速排序

【算法特点】

(1)记录非顺次的移动导致排序方法是不稳定的。

(2)排序过程中需要定位表的下界和上界，所以适合用于顺序结构，很难用于链式结构。

(3)当n较大时，在平均情况下快速排序是所有内部排序方法中速度最快的一种，所以其适合初始记录无序、 n较大时的情况。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 26

typedef int KeyType;
typedef char InfoType;

typedef struct
{
	KeyType key;
	InfoType otherinfo;
}RedType;

typedef struct
{
	RedType r[MAXSIZE + 1];  //r[O]闲置或用做哨兵单元
	int length;
}SqList;

void CreateSqList(SqList& L);
int Partition(SqList& L, int low, int high);
void QSort(SqList& L, int low, int high);
void QuickSort(SqList& L);
void printSqList(SqList L);

int main()
{
	SqList L = { {0},0 };

	CreateSqList(L);
	QuickSort(L);
	printSqList(L);

	return 0;
}

void CreateSqList(SqList& L)
{
	int i = 0;

	printf("请输入顺序表的元素个数：");
	scanf_s(" %d", &L.length);

	for (i = 1; i <= L.length; i++)
	{
		printf("请输入第%d个关键字：", i);
		scanf_s(" %d", &L.r[i].key);
	}
}

//算法8.5 快速排序
//对顺序表L中的子表r[low...high]进行一趟排序，返回枢轴位置
int Partition(SqList& L, int low, int high)
{
	L.r[0] = L.r[low];
	KeyType 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;  //返回枢轴位置
}

//对顺序表L中的子序列L.r[low ..high]做快速排序
void QSort(SqList& L, int low, int high)
{
	if (low < high)
	{
		//对顺序表L.r[low...high]先进行一趟快速排序，使之一分为二，pivotloc是枢轴位置
		int pivotloc = Partition(L, low, high);

		//对左、右子表进行递归排序
		QSort(L, low, pivotloc - 1);
		QSort(L, pivotloc + 1, high);
		/*   当子表不断往下分，直到分到某一子表中仅有三个或两个元素时，因为均无法通过该子表的左右子表QSort函数中的if语句，
            此时，对该含有三个或两个元素的子表的快速排序就结束了。
			之后，会返回到分出该含有三个或两个元素的子表的那一层快速排序递归，进行后面的步骤。	*/
	}
}

//对顺序表L做快速排序
void QuickSort(SqList& L)
{
	QSort(L, 1, L.length);
}

void printSqList(SqList L)
{
	int i = 0;

	printf("\n\n排序后的序列为：");
	for (i = 1; i <= L.length; i++)
	{
		printf("\nr[%d].key = %d", i, L.r[i].key);
	}
}


8.4 选择排序

8.4.1 简单选择排序

【算法特点】

(1)就选择排序方法本身来讲，它是一种稳定的排序方法，但下图所表现出来的现象是不稳定的，这是因为第一种实现选择排序的算法采用 "交换记录" 的策略所造成的，改变这个策略，可以写出不产生 "不稳定现象" 的选择排序算法。

选择排序的稳定解法 --------- Jekk_cheng

(2)可用于链式存储结构。

(3)移动记录次数较少，当每一记录占用的空间较多时，此方法比直接插入排序快。

8.4.1.1 不稳定解法

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 26

typedef int KeyType;
typedef char InfoType;

typedef struct
{
	KeyType key;
	InfoType otherinfo;
}RedType;

typedef struct
{
	RedType r[MAXSIZE + 1];  //r[O]闲置或用做哨兵单元
	int length;
}SqList;

void CreateSqList(SqList& L);
void SelectSort(SqList& L);
void printSqList(SqList L);

int main()
{
	SqList L = { {0},0 };

	CreateSqList(L);
	SelectSort(L);
	printSqList(L);

	return 0;
}

void CreateSqList(SqList& L)
{
	int i = 0;

	printf("请输入顺序表的元素个数：");
	scanf_s(" %d", &L.length);

	for (i = 1; i <= L.length; i++)
	{
		printf("请输入第%d个关键字：", i);
		scanf_s(" %d", &L.r[i].key);
	}
}

//算法8.6 简单选择排序
void SelectSort(SqList& L)
{
	int i = 0;
	int j = 0;
	int k = 0;
	RedType temp = { 0,'\0' };

	/* 整个序列刚开始第一趟（i = 1）是没有有序部分的，全部都属于无序部分。
	   从第二趟开始（i>=2），在进行下一趟简单选择排序之前，从L.r[1]到L.r[i-1]是序列中的有序部分。
	   最多进行n-1趟。  */
	for (i = 1; i < L.length; ++i)
	{
	   /********* 求序列无序部分（从L.r[i]到L.r[L.length]）的最小关键字下标，并记录在k中 *********/

		k = i;   //k的初始值为无序部分第一个元素的下标i
		for (j = i + 1; j <= L.length; ++j)
		{
			if (L.r[j].key < L.r[k].key)
			{
				k = j;
			}
		}

		//k == i 说明无序部分最小关键字即为无序部分的第一个元素L.r[i]，不用进行交换
		if (k != i)
		{
			temp = L.r[i];
			L.r[i] = L.r[k];
			L.r[k] = temp;
		}
	}
}


void printSqList(SqList L)
{
	int i = 0;

	printf("\n\n排序后的序列为：");
	for (i = 1; i <= L.length; i++)
	{
		printf("\nr[%d].key = %d", i, L.r[i].key);
	}
}


8.4.1.2 稳定解法

选择排序的稳定解法 --------- Jekk_cheng

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 26

typedef int KeyType;
typedef char InfoType;

typedef struct
{
	KeyType key;
	InfoType otherinfo;
}RedType;

typedef struct
{
	RedType r[MAXSIZE + 1];  //r[O]闲置或用做哨兵单元
	int length;
}SqList;

void CreateSqList(SqList& L);
void SelectSort(SqList& L);
void printSqList(SqList L);

int main()
{
	SqList L = { {0},0 };

	CreateSqList(L);
	SelectSort(L);
	printSqList(L);

	return 0;
}

void CreateSqList(SqList& L)
{
	int i = 0;

	printf("请输入顺序表的元素个数：");
	scanf_s(" %d", &L.length);

	for (i = 1; i <= L.length; i++)
	{
		printf("请输入第%d个关键字：", i);
		scanf_s(" %d", &L.r[i].key);
	}
}

//算法8.6 简单选择排序（采取稳定策略）
void SelectSort(SqList& L)
{
	int i = 0;
	int j = 0;
	int k = 0;
	RedType temp = { 0,'\0' };

	/* 整个序列刚开始第一趟（i = 1）是没有有序部分的，全部都属于无序部分。
	   从第二趟开始（i>=2），在进行下一趟简单选择排序之前，从L.r[1]到L.r[i-1]是序列中的有序部分。
	   最多进行n-1趟。  */
	for (i = 1; i < L.length; ++i)
	{
	   /********* 求序列无序部分（从L.r[i]到L.r[L.length]）的最小关键字下标，并记录在k中 *********/

		k = i;   //k的初始值为无序部分第一个元素的下标i
		for (j = i + 1; j <= L.length; ++j)
		{
			if (L.r[j].key < L.r[k].key)
			{
				k = j;
			}
		}

		/* 无序部分（从L.r[i]到L.r[L.length]）的最小关键字为L.r[k]
		 k == i 说明无序部分最小关键字即为无序部分的第一个元素L.r[i]，不会进行移动

		否则，就把L.r[k]前面的无序元素（从L.r[i]到L.r[k-1]），依次向后移动一个，
		再将最小关键字插入到有序部分的后面（也是此时无序部分的第一个）L.r[i]处 */

		temp = L.r[k];
		//printf("\n\n最小值为：temp = L.r[%d] = %d", k, L.r[k]);

		while(k != i)
		{
			//printf("\n L.r[k - 1] = L.r[%d] = %d", k - 1, L.r[k - 1]);
			L.r[k] = L.r[k - 1];
			k--;
		}

		L.r[i] = temp;
	}
}


void printSqList(SqList L)
{
	int i = 0;

	printf("\n\n排序后的序列为：");
	for (i = 1; i <= L.length; i++)
	{
		printf("\nr[%d].key = %d", i, L.r[i].key);
	}
}

8.4.2 树形选择排序 / 锦标赛排序

8.4.3 堆排序

【算法特点】

(1)是不稳定排序。

(2) 只能用于顺序结构，不能用于链式结构 。

(3)初始建堆所需的比较次数较多，因此记录数较少时不宜采用。

【在处理大量数据时，堆排序是一个很好的选择，因为它具有较好的平均性能；

但是在处理少量数据时，由于初始建堆的成本相对较高，这个过程需要进行大量的比较操作，对于较大的数组来说，这个开销是可以接受的，因为之后的排序过程中每次只需要O(nlog2n)的时间来维护堆。但是对于较小的数组，这个预先构建堆的操作就显得相对成本较高，不如直接使用一些简单排序算法来得高效。】

堆排序在最坏情况下时间复杂度为O(nlog2n), 相对于快速排序最坏情况下的O(n^2)而言是一个优点，当记录较多时较为高效。

c 复制代码 
#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 26

typedef int KeyType;
typedef char InfoType;

typedef struct
{
	KeyType key;
	InfoType otherinfo;
}RedType;

typedef struct
{
	RedType r[MAXSIZE + 1];  //r[O]闲置或用做哨兵单元
	int length;
}SqList;

void CreateSqList(SqList& L);
void HeadAdjust(SqList& L, int s, int m);
void CreateHeap(SqList& L);
void HeapSort(SqList& L);
void printSqList(SqList L);

int main()
{
	SqList L = { {0},0 };

	CreateSqList(L);
	HeapSort(L);
	printSqList(L);

	return 0;
}

void CreateSqList(SqList& L)
{
	int i = 0;

	printf("请输入顺序表的元素个数：");
	scanf_s(" %d", &L.length);

	for (i = 1; i <= L.length; i++)
	{
		printf("请输入第%d个关键字：", i);
		scanf_s(" %d", &L.r[i].key);
	}
}

//算法8.7 筛选法调整堆
//假设r[s + l...m]已经是堆，将r[s...m]调整为以r[s]为根的大根堆
void HeadAdjust(SqList& L, int s, int m)
{
	RedType rc = L.r[s];
	int j = 0;

	for (j = 2 * s; j <= m; j *= 2)  //j = j*2
	{
		if (j < m && L.r[j].key < L.r[j + 1].key)
		{
			++j;
		}

		if (rc.key >= L.r[j].key)
		{
			break;
		}

		L.r[s] = L.r[j];
		s = j;
	}

	L.r[s] = rc;
}

//算法8.8 建初堆
//把无序序列L.r[l...n]建成大根堆
void CreateHeap(SqList& L)
{
	int n = L.length;
	int i = 0;

	for (i = n / 2; i > 0; --i)
	{
		HeadAdjust(L, i, n);
	}
}

//算法8.9 堆排序
//对顺序表L进行堆排序
void HeapSort(SqList& L)
{
	RedType x = { 0,'\0' };
	int i = 0;

	CreateHeap(L);  //初建堆

	for (i = L.length; i > 1; --i)
	{
		x = L.r[1];
		L.r[1] = L.r[i];
		L.r[i] = x;

		HeadAdjust(L, 1, i - 1);
	}
}

void printSqList(SqList L)
{
	int i = 0;

	printf("\n\n排序后的序列为：");
	for (i = 1; i <= L.length; i++)
	{
		printf("\nr[%d].key = %d", i, L.r[i].key);
	}
}
相关推荐
一直学习永不止步3 分钟前
LeetCode题练习与总结：赎金信--383
java·数据结构·算法·leetcode·字符串·哈希表·计数
兆。3 分钟前
掌握 PyQt5：从零开始的桌面应用开发
开发语言·爬虫·python·qt
尘浮生6 分钟前
Java项目实战II基于Spring Boot的光影视频平台（开发文档+数据库+源码）
java·开发语言·数据库·spring boot·后端·maven·intellij-idea
明月看潮生26 分钟前
青少年编程与数学 02-003 Go语言网络编程 15课题、Go语言URL编程
开发语言·网络·青少年编程·golang·编程与数学
小刘|34 分钟前
《Java 实现希尔排序：原理剖析与代码详解》
java·算法·排序算法
南宫理的日知录37 分钟前
99、Python并发编程：多线程的问题、临界资源以及同步机制
开发语言·python·学习·编程学习
jjyangyou39 分钟前
物联网核心安全系列——物联网安全需求
物联网·算法·安全·嵌入式·产品经理·硬件·产品设计
逊嘘1 小时前
【Java语言】抽象类与接口
java·开发语言·jvm
xinghuitunan1 小时前
蓝桥杯顺子日期（填空题）
c语言·蓝桥杯
van叶～1 小时前
算法妙妙屋-------1.递归的深邃回响：二叉树的奇妙剪枝
c++·算法
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play