实验九 排序算法的实现

最新推荐文章于 2022-10-09 06:00:00 发布
最新推荐文章于 2022-10-09 06:00:00 发布
阅读量1.5k 收藏 28
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43599023/article/details/88068080
版权

 

1.实验目的

熟悉排序的方法、过程及原则。掌握插入排序、快速排序、选择排序、归并排序的算法思想及实现方法，掌握其时间复杂度的分析方法。

2.实验内容

定义待排序序列的存储结构。验证插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序中各排序方法中的一、二个排序算法。

  1. 插入类排序：直接插入排序、希尔排序
  2. 交换类排序：冒泡排序、快速排序
  3. 选择类排序：简单选择排序、堆排序
  4. 归并类排序：递归和非递归形式的归并排序
#include<stdio.h>
#define MAXSIZE 20

typedef int KeyType;//定义关键字类型为整数类型
typedef int InfoType;

typedef struct {
	KeyType key;//关键字项 
	InfoType otherinfo;//其他数据项 
}RedType;//记录类型 
typedef struct {
	RedType  r[MAXSIZE + 1];//用r[0] 做闲置或者做哨兵单元
	int length;//顺序表长度 
}SqList;//顺序表类型


void InsertSort(SqList *L)
{//对顺序表L做直接插入排序 
	int i, j;
	for (i = 2; i <= L->length; i++)
		if (L->r[i].key < L->r[i - 1].key)
		{
			L->r[0] = L->r[i];//复制为哨兵
			L->r[i] = L->r[i - 1];
			for (j = i - 2; L->r[0].key < L->r[j].key; --j)
				L->r[j + 1] = L->r[j];//记录后移 
			L->r[j + 1] = L->r[0]; //插入到正确的位置上 		
		}
}

void Show(SqList L)
{
	int i;
	for (i = 1; i <= L.length; i++)
		printf("%4d", L.r[i].key);
	printf("\n");
}

int main()
{
	SqList L;
	int i;
	printf("输入线性表的长度：");
	scanf_s("%d", &L.length);
	printf("输入线性表中的元素：");
	for (i = 1; i <= L.length; i++)
		scanf_s("%d", &L.r[i].key);
	InsertSort(&L);
	printf("直接插入的排序结果是;");
	Show(L);
	system("pause");
	return 0;
}

 

 

#include<stdio.h>

#define MAXSIZE 10
typedef int KeyType;
typedef int InfoType;
typedef struct {
	KeyType key;		//关键字项
	InfoType otherinfo;	// 其他数据项
} RedType;

typedef struct {
	RedType r[MAXSIZE + 1];//r[0]做闲置或者哨兵单元
	int length;			//顺序表长度
} SqList;				//顺序表类型

void ShellInsert(SqList *L, int dk) {
	//对顺序表L做一趟希尔插入排序，本算法
	//1.前后记录 位置的增量是dk,不是1
	//2.r[0]只是暂存单元，不是哨兵，当j<=0时 ，插入位置已经找到
	int i, j;
	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 = j - dk)
				L->r[j + dk] = L->r[j];//记录后移，查找插入位置
			L->r[j + dk] = L->r[0];//插入
		}
}

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


void Show(SqList L) {
	int i;
	for (i = 1; i <= L.length; i++)
		printf("%4d", L.r[i].key);
	printf("\n");
}



int main() {

	SqList L;
	int i;
	int dlta[3] = { 5,3,1 };
	printf("输入线性表的长度：");
	scanf_s("%d", &L.length);
	printf("输入线性表中的元素：");
	for (i = 1; i <= L.length; i++)
		scanf_s("%d", &L.r[i].key);
	SellSort(&L, dlta, 3);
	printf("希尔排序结果是;");
	Show(L);
	system("pause");
	return 0;
}

 

 

#include<stdio.h>

#define MAXSIZE 10
typedef int KeyType;
typedef int InfoType;
typedef struct {
	KeyType key;		//关键字项
	InfoType otherinfo;	// 其他数据项 
}RedType;

typedef struct {
	RedType r[MAXSIZE + 1];//r[0]做闲置或者哨兵单元
	int length;			//顺序表长度 
}SqList;				//顺序表类型

int Partition(SqList *L, int low, int high)
{//交换顺序表L中子表r[low..high]的记录，枢轴记录到位，并返回所在位置
  //此时在他之前的（后）的记录均不大（小）于他 
	int pivokey;
	L->r[0] = L->r[low];//用子表的第一个记录做枢轴记录
	pivokey = L->r[low].key; //枢轴记录关键字
	while (low < high)
	{//从表的两端交替的向中间扫描 

		while (low < high&&L->r[high].key >= pivokey)
		{
			--high;//high指针指向的元素比枢轴大，high指针就向前移动 
		}
		L->r[low] = L->r[high];//将比枢轴记录小的记录移动到底端 

		while (low < high&&L->r[low].key <= pivokey)
		{
			++low;//low指针指向的元素比枢轴小，low指针就向后移动
		}
		L->r[high] = L->r[low];//将比枢轴大的记录移动到后端 	   

	}
	L->r[low] = L->r[0];//枢轴记录到位 
	return low;
}

void QSort(SqList *L, int low, int high)
{//对顺序表L中的子序列 L.r[low..high]做快速排序 
	int pivotloc;
	if (low < high)
	{
		pivotloc = Partition(L, low, high);//将L一分为二 
		QSort(L, low, pivotloc - 1);//对低子表递归排序，pivotloc是枢轴位置
		QSort(L, pivotloc + 1, high);//对高子表递归排序 		
	}
}

void QuickSort(SqList *L)
{//对顺序表L进行快速排序 
	QSort(L, 1, L->length);
}

void Show(SqList L)
{
	int i;
	for (i = 1; i <= L.length; i++)
		printf("%4d", L.r[i].key);
	printf("\n");
}

int main()
{
	SqList L;
	int i;
	printf("输入线性表的长度：");
	scanf_s("%d", &L.length);
	printf("输入线性表中的元素：");
	for (i = 1; i <= L.length; i++)
		scanf_s("%d", &L.r[i].key);
	QuickSort(&L);
	printf("快速排序结果是;");
	Show(L);
	system("pause");
	return 0;
}

 

 

#include<stdio.h>
#define MAX 10000
#define MAXSIZE 10
typedef int KeyType;
typedef int InfoType;
typedef struct {
	KeyType key;		//关键字项
	InfoType otherinfo;	// 其他数据项
} RedType;

typedef struct {
	RedType r[MAXSIZE + 1];//r[0]做闲置或者哨兵单元
	int length;			//顺序表长度
} SqList;				//顺序表类型


int SelectMiniKey(SqList L, int i) {
	int minik;
	int mini = MAX;
	for (i; i <= L.length; i++) {
		if (L.r[i].key < mini) {
			mini = L.r[i].key;
			minik = i;
		}
	}
	return minik;
}
void SelectSort(SqList *L) {
	//对顺序表进行简单选择排序

	int i, j, temp;
	for (i = 1; i <= L->length; i++) { //选择第i小记录，并交换到位
		j = SelectMiniKey(*L, i);//在L.r[i..L.length]中选择Key最小的记录
		if (i != j) {
			temp = L->r[i].key;
			L->r[i].key = L->r[j].key;
			L->r[j].key = temp;
		}
	}
}

void Show(SqList L) {
	int i;
	for (i = 1; i <= L.length; i++)
		printf("%4d", L.r[i].key);
	printf("\n");
}


int main() {

	SqList L;
	int i;
	printf("输入线性表的长度：");
	scanf_s("%d", &L.length);
	printf("输入线性表中的元素：");
	for (i = 1; i <= L.length; i++)
		scanf_s("%d", &L.r[i].key);
	SelectSort(&L);
	printf("简单选择排序结果是;");
	Show(L);
	system("pause");
	return 0;
}

 

 

#include<stdio.h>
#define MAX 10000
#define MAXSIZE 10
typedef int KeyType;
typedef int InfoType;

typedef struct {
	KeyType key;		//关键字项
	InfoType otherinfo;	// 其他数据项
} RedType;

typedef struct {
	RedType r[MAXSIZE + 1];//r[0]做闲置或者哨兵单元
	int length;			//顺序表长度
} SqList;				//顺序表类型
typedef SqList HeapType;//堆排序用顺序表存储表示 
void HeapAdjust(HeapType *H, int s, int m)
{
	//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，
	//本函数调整H.r[s] 的关键字，使H.r[s..m]成为一个大顶堆（对其中记录的关键字而言）
	RedType rc;
	int j;
	rc = H->r[s];
	for (j = 2 * s; j <= m; j = j * 2)
	{//沿着key较大的孩子结点向下筛选
		if (j < m && (H->r[j].key < H->r[j + 1].key))
			j++;//j为key较大的记录的下标
		if (!(rc.key < H->r[j].key))
			break;
		H->r[s] = H->r[j];
		s = j;
	}
	H->r[s] = rc;//插入 
}

void HeapSort(HeapType *H)
{//对顺序表H进行堆排序 
	RedType temp;
	int i;
	for (i = H->length / 2; i > 0; --i)//把H.r[1..H.length] 建成大顶堆
		HeapAdjust(H, i, H->length);
	for (i = H->length; i > 1; --i)
	{
		temp = H->r[1];
		H->r[1] = H->r[i];
		H->r[i] = temp;//将堆顶记录和当前未经排序的子序列H.r[1..i]中最后一个记录相互交换
		HeapAdjust(H, 1, i - 1);//将H.r[1..i-1]重新调整为大顶堆 
	}
}

void Show(SqList L)
{
	int i;
	for (i = 1; i <= L.length; i++)
		printf("%4d", L.r[i].key);
	printf("\n");
}

int main()
{
	HeapType H;
	int i;
	printf("输入线性表的长度：");
	scanf_s("%d", &H.length);
	printf("输入线性表中的元素：");
	for (i = 1; i <= H.length; i++)
		scanf_s("%d", &H.r[i].key);

	HeapSort(&H);
	printf("堆排序结果是;");
	Show(H);
	system("pause");
	return 0;
}

 

 

心、若止水
关注
  • 3
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实验 9 排序算法实验比较
01-25
数据结构课程实验九代码，仅供参考~ 实验目的 基于教材内容，任选两种排序算法，实现并比较性能。 基本要求 （1）至少要有一种排序算法的性能优于 O(n2 ) （2）对实现的排序算法进行实验比较，实验比较数据参见教材 7.8 章节 （3）排序算法要基于教材，测试输入的整数数据文件（5 个，文件中数据规模分别是 100，1K，10K，100K 和 1M），排序结果也要输出到文件中。 （4）要在屏幕上输出排序过程所花费时间。
实验9 排序算法实验比较
qq_45755193的博客
01-10 1544
排序算法实验比较（实验报告） 一、源码编写与调试 | 时间：2021.1.2 | 实验完成度：40% | 实验目的： 基于教材内容，选择直接插入排序和归并排序两种排序算法，实现并比较其性能。 实验过程： 1.先随机生成数据规模分别为100，1K，10K，100K和1M的5个TXT文件，用于排序的测试。 2.对源码进行编写，熟悉文件流操作和C++的微秒定时操作。 3.对源码进行编译，对于不同数据规模的数据，使用直接插入排序算法和归并排序算法各进行处理，将排序结果输出到文件中，且在屏幕上输出排序过程所花费时间
C语言数据结构--排序算法
pointer
02-25 421
#ifndef GRAPH_H #define GRAPH_H #include<limits.h> #include"Head.h" #define MAX_VERTEX_NUM 20 typedef enum { DG, DN, UDG, UDN }GraphKind;//有向图，有向网，无向图，无向网 typedef int VRType; typedef char ...
实验八：排序算法的实现-数据结构
pitepa的博客
12-13 3024
实验八：排序算法的实现一、实验实习目的及要求二、实验实习设备（环境）及要求（软硬件条件）三、实验实习项目、内容与步骤四、实验实习所得结果及分析五、实验实习结果分析和（或）源程序调试过程 一、实验实习目的及要求 1. 掌握常用的排序方法，并掌握用高级语言实现排序算法的方法； 2. 深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用； 3. 了解各种方法的排序过程及其时间复杂度的分析方法。 二、实验实习设备（环境）及要求（软硬件条件） 实验在计算机机房，应用软件VC++； 三、实验实习项目、内容与
常见排序及代码实现
5683的博客
09-17 439
1 冒泡排序 1.1 排序说明 所谓冒泡，说的是每次都是相邻元素进行比较，从开始索引到结束索引，不断冒出的过程。 以升序为例： 第一轮 所有元素都参与，从索引0元素开始，和索引1元素相较，如果索引大的数值小，则互换位置，接着索引1元素继续以同样的方式和索引2元素相较……一直到最后一个元素。 第一轮下来，就能将所有元素中最大的元素冒泡到最后索引的位置。 第二轮 一样从索引0元素开始冒泡，不过第一轮已经确定最后一个为最大元素，所以这次只需要冒泡到倒数第二个元素。 第二轮也一样，可以将这次参与冒泡的元素中的最大
数据结构实验课：实验八、排序算法的实现
热门推荐
listboy的博客
05-19 1万+
实验八、排序算法的实现 一、实验目的 掌握常用的排序方法，并掌握用高级语言实现排序算法的方法； 深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用； 了解各种方法的排序过程及其时间复杂度的分析方法。 二、实验要求 统计成绩：给出n个学生的考试成绩表，每条信息由姓名和分数组成，试设计一个算法： （1） 按分数高低次序，打印出每个学生在考试中获得的名次，分数相同的为同一名次； （2） 按名次列出每个学生的姓名与分数。 三、实验步骤 1.定义结构体。 Typedef struct student {
实验八 排序算法的实现
weixin_52841358的博客
04-15 1363
实验八 排序算法的实现 一、实验实习目的及要求 掌握常用的排序方法，并掌握用高级语言实现排序算法的方法； 深刻理解排序的定义和各种排序方法的特点，并能加以灵活应用； 了解各种方法的排序过程及其时间复杂度的分析方法。 二、实验实习设备（环境）及要求（软硬件条件） 实验室，使用VC上机调试出正确结果 三、实验实习项目、内容与步骤 统计成绩：给出n个学生的考试成绩表，每条信息由姓名和分数组成，试设计一个算法： （1） 按分数高低次序，打印出每个学生在考试中获得的名次，分数相同的为同一名次； （2） 按名次列出
广州大学 数据结构实验报告 实验四 查找和排序算法实现
05-23
实验报告的主题聚焦于数据结构中的查找和排序算法实现，这是计算机科学中基础且重要的部分，尤其是在处理大量数据时。以下是对这些算法的详细说明： 1. **插入排序**：插入排序的基本思想是将一个记录插入到已经排...
排序算法实现实验报告.doc
05-07
**排序算法实现实验报告** 本实验报告主要探讨了数据结构中的几种常见排序算法的实现与性能比较。排序是计算机科学中最基础且重要的操作之一，它在各种领域都有广泛的应用，如数据库、数据分析等。实验的目标是加深...
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
数据库实验 包含九个实验 有多种排序算法 链表的插入删除翻转等
11-14
数据库实验 包含九个实验 有多种排序算法 链表的插入删除翻转等 树的三种遍历算法 字符串算法 移位密码 代换密码等
实验十 排序算法1
08-03
本实验主要关注三种经典的排序算法：冒泡排序、选择排序和快速排序，通过对这些算法的理解、实现和分析，可以提升对算法效率和性能的理解。 1. 冒泡排序（Bubble Sort） 冒泡排序是一种简单的排序算法，通过比较...
python 常见的排序算法实现汇总
12-16
要求能够手写时间复杂度位O(nlogn)的排序算法：快速排序、归并排序、堆排序 1.冒泡排序 思想：相邻的两个数字进行比较，大的向下沉，最后一个元素是最大的。列表右边先有序。 时间复杂度$O(n^2)$，原地排序，稳定的...
顺序查找（数组，顺序表，单链表C语言实现）
qq_57610691的博客
11-29 3142
顺序查找(SequentialSearch)又叫线性查找,是最基本的查找技术,它的查找过程是:从表中第一个(或最后一个)记录开始,逐个进行记录的关键字和给定值比较,若某个记录的关键字和给定值相等,则查找成功,找到所查的记录;如果直到后一个(或第一个)记录,其关键字和给定信比较都不等时,则表中没有新金录,査找不成功。 1.数组实现 #include<stdio.h> #include<stdlib.h> typedef int KeyType; typede...
6-1 二叉排序树查找操作 (6分)
caixiaozhi123的博客
06-07 9514
本题要求实现二叉排序树的查找操作。 函数接口定义： BSTree SearchBST(BSTree T,ElemType e); 其中BSTree结构定义如下： typedef int ElemType; typedef struct BSTNode { ElemType data; struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; 裁判测试程序样例： #include <stdio.h> #include <stdlib.h&
数据结构实验完结撒花之内部排序比较
菱形继承
12-20 260
实验目的： 比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序； 实验要求： 待排序长度不小于100，数据可有随机函数产生，用五组不同输入数据做比较，比较的指标为关键字参加比较的次数和关键字移动的次数； 对结果做简单的分析，包括各组数据得出结果的解释； 设计程序用顺序存储。 实验内容 对各种内部排序算法的时间复杂度有一个比较直观的感受，包括关键字比较次数和关键...
【数据结构】插入排序 — 希尔排序
四季轮换叶，一路招摇胜
10-09 1340
​希尔排序(Shell's Sort)是插入排序的一种又称“缩小增量排序”，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。 ​
C++代码，数据结构-内部排序-插入排序-Shell排序
y519476132的专栏
03-09 658
希尔排序，又称缩小增量排序，在时间效率上较前几种插入排序类的方法有较大的改进 我们都知道直接插入排序的效率取决于序列的初始状态，而希尔排序可以通过巧妙的方法将序列经过几趟排序，使得序列在进行一次直接插入排序的时候效率大大的增加， 对于希尔排序，我目前的认识也只能达到可以写出算法，已经基本理解此算法，但更深的理解还是没有的，只是觉得很巧妙 #include using namespace st
思维进化算法优化BP神经网络——非线性函数拟合.rar
最新发布
07-26
神经网络的matlab案例，本案例介绍如下： 技术深度：案例详细介绍了如何使用MATLAB进行深度学习模型的构建、训练和测试。 实际应用：通过具体的图像识别任务，展示模型的实际应用效果，让你直观感受神经网络的强大能力。 代码解析：提供完整的MATLAB代码，并对关键部分进行详细注释，帮助你理解每一步的工作原理。 优化策略：探讨不同的训练策略和参数调整方法，优化模型性能。
排序算法实现及性能分析实验总结
排序算法的实现是计算机程序设计中非常重要的一部分，本次实验旨在帮助学生掌握各种排序算法的思路和方法，以及在C语言环境中的实现方法。在实验中，学生需要完成基于静态数组的存储结构的多种排序算法，包括直接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值