数据结构排序系统C实现（低时间、空间复杂度）

最新推荐文章于 2023-03-09 15:46:59 发布
最新推荐文章于 2023-03-09 15:46:59 发布
阅读量646 收藏 5
点赞数 4
分类专栏： C与数据结构 文章标签： 数据结构基础 C语言应用 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjzjyx_/article/details/89074714
版权
一、需求
1.实现插入排序有关算法（直接插入排序、折半插入排序、希尔排序）
2.实现交换排序有关算法（冒泡排序、快速排序）
3.实现选择排序有关算法（简单选择排序、堆排序）
4.其他排序算法（归并排序、基数排序）
二、解决方案
1.采用顺序存储结构，待排关键字个数可变
2.采用顺序表判空函数和清空函数，实现一块内存多次使用，实现最低空间复杂度
三、代码
#include "pch.h"
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include"string.h"
#include"math.h"
#include<Windows.h>
#define MAXSIZE 100   //顺序表最大长度
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define RADIX 10
#define MAX_NUM_OF_KEY 8
#define MAX_SPACE 10000
typedef int KeyType;    //关键字类型
typedef int Status;
typedef struct
{
	KeyType key;
}RedType;
typedef struct
{
	RedType r[MAXSIZE + 1];     //r[0]闲置或用作哨兵单元
	int length ;
}SqList;
/**************创建顺序表******************/
Status InitSqList(SqList *S)
{
	S->length = 0;
	return OK;
}
/******************输入*********************/
Status Input(SqList *S)
{
	int n;
	printf("请输入待排整数序列的长度:");
	scanf_s("%d", &n);
	printf("请输入待排整数序列的关键字:");
	for (int i = 1; i <=n; i++)
	{
		scanf_s("%d", &S->r[i].key);
		S->length++;    //顺序表长度与关键字个数统一，第二次调用Input,时length的内容已经被清空
	}
	return OK;
}
/*************直接插入排序******************/
Status InsearSort(SqList *S)   
{
	int j;
	printf("直接插入排序后");
	for (int i = 0; i <= S->length; ++i)
		if (S->r[i].key < S->r[i - 1].key)
		{
			S->r[0] = S->r[i];
			S->r[i] = S->r[i - 1];
			for (j = i - 2; S->r[0].key < S->r[j].key; --j)
				S->r[j + 1] = S->r[j];
			S->r[j + 1] = S->r[0];
		}
	return OK;
}
/****************折半插入排序****************/
Status BInsertSort(SqList *S)   
{
	int low, high, mid;
	int i, j;
	printf("折半插入排序后");
	for (i = 2; i <= S->length; ++i)
	{
		S->r[0] = S->r[i];
		low = 1, high = i - 1;
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (S->r[0].key < S->r[mid].key)
				high = mid - 1;
			else
				low = mid + 1;
		}
		for (j = i - 1; j >= high + 1; --j)
			S->r[j + 1] = S->r[j];
		S->r[high + 1] = S->r[0];
	}
	return OK;
}
/*************冒泡排序优化算法**************/
Status BubbleSort(SqList *S)  
{
	printf("冒泡排序后");
	RedType tampe;
	int change = TRUE;
	for (int i = S->length; i > 1 && change; i--)
	{
		change = FALSE;
		for (int j = 1; j < i; ++j)
			if (S->r[j].key > S->r[j + 1].key)
			{
				tampe = S->r[j];
				S->r[j] = S->r[j + 1];
				S->r[j + 1] = tampe;
				change = TRUE;
			}
	}
	return OK;
}
/****************选择排序****************/
Status SelectSort(SqList *S)  
{
	printf("选择排序后");
	int i, j, k;
	for (i = 1; i <= S->length - 1; i++)
	{
		k = i;
		for (j = i + 1; j <= S->length; ++j)
			if (S->r[j].key < S->r[k].key)
				k = j;
		if (k != i)
		{
			RedType tampe = S->r[i];
			S->r[i] = S->r[k];
			S->r[k] = tampe;
		}
	}
	return OK;
}
/**************希尔排序***************/
Status ShellInsert(SqList *S)  
{
	printf("希尔排序后");
	int dk, i, j;
	for (dk = S->length / 2; dk >= 1; dk = dk / 2)
	{
		for (i = dk + 1; i <= S->length; ++i)
			if (S->r[i].key < S->r[i - dk].key)
			{
				S->r[0] = S->r[i];
				for (j = i - dk; j > 0 && S->r[0].key < S->r[j].key; j -= dk)
					S->r[j + dk] = S->r[j];
				S->r[j + dk] = S->r[0];
			}
	}
	return OK;
}
/*****************快速排序**************/

int Partition(SqList *S, int low, int high)  //交换顺序表中子表r[low..high]的记录，枢轴记录到位，并返回其所在位置
{
	S->r[0] = S->r[low];
	KeyType pivotkey = S->r[low].key;
	while (low < high)
	{
		while (low < high&&S->r[high].key >= pivotkey)
			--high;
		S->r[low] = S->r[high];
		while (low < high&&S->r[low].key <= pivotkey)
			++low;
		S->r[high] = S->r[low];
	}
	S->r[low] = S->r[0];
	return low;
}
Status QSort(SqList *S, int low, int high)   //对顺序表中的子序列S.r[low..high]做快速排序
{
	if (low < high)
	{
		int pivotloc = Partition(S, low, high);
		QSort(S, low, pivotloc - 1);
		QSort(S, pivotloc + 1, high);
	}
	return OK;
}

Status QuickSort(SqList *S)   
{
	printf("快速排序后");
	QSort(S, 1, S->length);
	return OK;
}
/*****************堆排序******************/
Status HeapAdjust(SqList *S, int s, int m) 
{
	RedType rc = S->r[s];
	for (int j = 2 * s; j <= m; j *= 2)
	{
		if (j < m && (S->r[j].key < S->r[j + 1].key))
		{
			j++;
		}
		if (rc.key >= S->r[j].key) break;
		S->r[s] = S->r[j];
		s = j;
	}
	S->r[s] = rc;
	return OK;
}
Status HeapSort(SqList *S)
{
	printf("堆排序后");
	RedType tampe;
	for (int i = S->length / 2; i > 0; --i)
	{
		HeapAdjust(S, i, S->length);
	}
	for (int i = S->length; i > 1; i--)
	{
		tampe = S->r[1];
		S->r[1] = S->r[i];
		S->r[i] = tampe;
		HeapAdjust(S, 1, i - 1);
	}
	return OK;
}
/******************归并排序*******************/
Status Merge(RedType SR[], RedType TR[], int i, int m, int n)    //如果需要将一个数组当作实参传入函数，则应把对应的形参声明成下面的形式,RedType TR[],当把数组名作为函数实参时，它会自动被转换为指针
{
	int j, k;
	for (j = m + 1, k = i; i <= m && j <= n; ++k)
	{
		if (SR[i].key <= SR[j].key)
		{
			TR[k] = SR[i++];
		}
		else {
			TR[k] = SR[j++];
		}	
	}
	if (i <= m)
	{
		for (int a = 0; a <= m - i; a++)
			TR[k + a] = SR[i + a];
	}
	if (j <= n)
	{
		while (n - j >= 0)
			TR[k++] = SR[j++];
	}
	return OK;
}
Status MSort(RedType SR[], RedType TR1[], int s, int t)
{
	RedType TR2[MAXSIZE + 1];     //定义与结构体类型中类型大小相同的数组
	if (s == t)
		TR1[s] = SR[s];
	else
	{
		int m = (s + t) / 2;
		MSort(SR, TR2, s, m);
		MSort(SR, TR2, m + 1, t);
		Merge(TR2, TR1, s, m, t);

	}
	return OK;
}
Status MergeSort(SqList *S)
{
	//对整体做归并排序
	printf("归并排序后");
	MSort(S->r, S->r, 1, S->length);
	return OK;
}

/***************基数排序****************/
int maxbit(RedType r[], int length) //保存最大的位数
{
	int d = 1;
	int p = 10;
	for (int i = 1; i <= length; ++i)
	{
		while (r[i].key >= p)
		{
			p *= 10;
			++d;
		}
	}
	return d;
}

Status RadixSort(SqList *S)
{ 
	printf("基数排序后");
	int d = maxbit(S->r, S->length);
	RedType *tmp = (RedType *)malloc(S->length * sizeof(RedType));
	int count[10];
	int i, j, k;
	int radix = 1;
	for (i = 1; i <= d; i++)
	{
		for (j = 0; j < 10; j++)
			count[j] = 0;

		for (j = 1; j <= S->length; j++)
		{
			k = (S->r[j].key / radix) % 10; //统计每个桶中的记录数
			count[k]++;
		}

		for (j = 1; j < 10; j++)
			count[j] = count[j - 1] + count[j]; //确认数据所放的位置

		for (j = S->length; j > 0; j--)
		{
			k = (S->r[j].key / radix) % 10;
			tmp[count[k] - 1] = S->r[j];
			count[k]--;
		}

		for (j = 1; j <= S->length; j++) //将临时数组的内容复制到s.r中
			S->r[j] = tmp[j - 1];

		radix *= 10;
	}
	return OK;
}
Status Display(SqList S)  //显示函数
{
	printf("整数序列为:");
	for (int i = 1; i <= S.length; i++)
		printf("%d ", S.r[i].key);
	printf("\n");
	printf("\n");
	return OK;


}
Status ClearSqList(SqList *S)  //清空顺序表
{
	S->length = 0;
	return OK;
}

bool ListEmpty(SqList *S)   //顺序表判空
{
	return(S->length == 0);
}
int main()
{
	SqList S;
	InitSqList(&S);  //创建顺序表
	int i, k = 1;
	while (k)
	{
		printf("*--------------排序-------------*\n");
		printf("|         1.直接插入排序        |\n");
		printf("|         2.折半插入排序        |\n");
		printf("|         3.冒泡排序            |\n");
		printf("|         4.选择排序            |\n");
		printf("|         5.希尔排序            |\n");
		printf("|         6.快速排序            |\n");
		printf("|         7.堆排序              |\n");
		printf("|         8.归并排序            |\n");
		printf("|         9.基数排序            |\n");
		printf("|         0.结束程序            |\n");
		printf("*-------------------------------*\n");
		printf("请输入你的选择(0-9):");
		scanf_s("%d", &i);
		switch (i)
		{
		case 1: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			InsearSort(&S);
			Display(S);
			break;
		}
		case 2: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
				Input(&S);
			BInsertSort(&S);
			Display(S);
			break;
		}
		case 3: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			BubbleSort(&S);
			Display(S);
			break;
		}
		case 4: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			SelectSort(&S);
			Display(S);
			break;
		}
		case 5: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			ShellInsert(&S);
			Display(S);
			break;
		}
		case 6: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			QuickSort(&S);
			Display(S);
			break;
		}
		case 7: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			HeapSort(&S);
			Display(S);
			break;
		}
		case 8: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			MergeSort(&S);
			Display(S);
			break;
		}
		case 9: {
			if (!ListEmpty(&S))
				ClearSqList(&S);
			Input(&S);
			RadixSort(&S);
			Display(S);
			break;
		}
		case 0: {k = 0; printf("操作结束!"); break; }
		default:printf("输入有误，请重新输入!");
			break;
		}
	}
	system("pause");
	return 0;
}
四、运行结果演示

运行结果

Alina_ya
关注
专栏目录
c语言中各个排序方法的复杂度,排序算法的C语言实现以及各个算法的时间复杂度和空间复杂度分析（冒泡排序）...
weixin_36250200的博客
05-23 1193
排序算法是一种很重要的算法，在各个方面都有很多应用，下面用C语言实现一下各个排序算法，并总结一下各种排序算法的时间复杂度和空间复杂度。要总结的排序算法为：冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、归并排序、快速排序。(1)冒泡排序(最简单的初级版本)：假设我们有一个整型数组，数组里面的数的排位是随机的，要对他们进行升序排列。排序的思想如下：数组的第一个数和其他数依次进行比较，将较小的...
数据结构修炼第一篇：时间复杂度和空间复杂度
最新发布
m0_72018048的博客
04-13 946
时间复杂度和空间复杂度的介绍
数据结构排序算法演示系统
06-04
多种排序演算及原代码
快速排序（时间复杂度最小的排序）
qq_45571306的博客
03-09 302
时间复杂度最小的排序
一个很好的数据结构排序系统
bizhu的专栏
07-03 1999
这是我的一个同学给我修改的排序系统,我觉得挺好的,就分享一下 // Sort.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include #include #include #include #incl
各种排序算法比较(2):时间复杂度,空间复杂度
热门推荐
weiwenhp
02-28 6万+
  时间复杂度 n^2表示n的平方,选择排序有时叫做直接选择排序或简单选择排序   排序方法 平均时间 最好时间 最坏时间 桶排序(不稳定) O(n) O(n) O(n) 基数排序(稳定) O(n) O(n) O(n) 归并排序(稳定) O(nlogn) O(nlogn) O(nlogn) 快速排序(不...
时间复杂度较低排序算法c语言,JS排序算法总结：（六）归并排序
weixin_39627697的博客
05-24 521
目的：掌握 归并排序的基本思想与过程、代码实现、时间复杂度1、基本思想与过程：先递归的分解数列，再合并数列(分治思想的典型应用)(1)将一个数组拆成A、B两个小组，两个小组继续拆，直到每个小组只有一个元素为止。(2)按照拆分过程逐步合并小组，由于各小组初始只有一个元素，可以看做小组内部是有序的，合并小组可以被看做是合并两个有序数组的过程。(3)对左右两个小数列重复第二步，直至各区间只有1个数。下...
数据结构排序算法C语言实现
11-26
在IT领域，排序算法是计算机科学中的核心概念，特别是在数据结构和算法分析中。这里我们主要探讨的是使用C语言实现的几种经典排序算法。这些算法包括：插入排序、堆排序、归并排序、基数排序、快速排序、冒泡排序、...
【数据结构入门】算法的时间复杂度和空间复杂度详解
codewinter的博客
07-27 3883
【数据结构学习之路】算法的时间复杂度和空间复杂度 文章目录【数据结构学习之路】算法的时间复杂度和空间复杂度（1）算法效率（2）时间复杂度的计算1）什么是时间复杂度2）大O渐进表示法（估算）3）时间复杂度计算实例4）总结5）一些思考（3）空间复杂度的计算（4）常见复杂度对比 本篇前言 在C语言阶段，我们学过了一些排序和查找算法，冒泡排序，快速排序，二分查找等等，哪种算法更好呢，我们如何衡量一个算法的好坏呢？本篇来学习算法的时间复杂度和空间复杂度，相信学完后你就会明白了。 （1）算法效率 算法在编写成可执行
【数据结构初阶】时间复杂度和空间复杂度
m0_60624580的博客
10-24 1377
数据结构初阶用C语言实现。
数据结构--五种排序
11-14
南开大学计算机科学与技术数据结构辛运帏老师五种排序代码
6种排序算法的排序系统
01-10
能选择六种排序任意一个排序算法进行排序，并输出结果 1：自定义一个大小和元素的数组。 2：有六种排序算法供选择。 3：用所选择的算法进行排序 4：能循环使用。
数据结构【时间复杂度、空间复杂度--1】
我心如火
04-20 2751
本期知识：什么是数据结构？.算法的复杂度，时间复杂度概念及其例题讲解，空间复杂度概念及其例题讲解，常见时间复杂度以及复杂度oj练习
数据结构-排序线性表实现学生管理系统
aids1990的博客
07-18 495
1. 树的定义 由n（n>=0）个结点的有限集。n=0表示空树。 n>1 满足： (1) 有且只有一个根结点。 (2) 其余结点分成互不相交的m个子集T1、T2、...、Tm,每个集合又都是一颗树。 注意：1）树可以是空树。 1）树的定义具有递归性 （树中有树）。 2. 树的术语 (1) 根：即根结点...
排序系统
墨海灬流弈的博客
12-29 376
备注： 内部包含6种排序方式。 #include<iostream> using namespace std; typedef int ElementType; //交换 void Swap(ElementType *a,ElementType *b) { ElementType t=*a; *a=*b; *b=t; } //输出 void puts(ElementType A[],int N) { int i=0; for(i=0;i<N;i++) { cout&lt
单链表的原地排序算法（最低时间空间复杂度）——司
司豆豆的博客
06-19 1703
这里我带来了链表的原地排序。 算法思想：纯粹利用了排序算法中的“插入排序”原理 代码如下： void List_sort(link &head){ link q, p, s; q = head; p = head->next->next;//从第二个结点开始遍历 head->next->next = NULL; //从第一个结点后断开 while (p != NULL){ s = p;//用s来保存p p = p->next;//p遍历下一个 wh
快速排序 时间复杂度最小的算法
qq_45571306的博客
03-09 303
时间复杂度最小的算法
数据结构（排序算法总结）（C语言）
x18261294286的博客
08-03 7541
排序算法常见的有八种： 算法一：插入排序 插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。 算法步骤： 1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。 2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某...
时间复杂度和空间复杂度最低的查找算法
u013983095的专栏
01-05 2608
直接上例子： 有列表1是[2,3,6,7,8,9] 列表1里面最大的数是9 可以生成列表2，里面10个0 [0,0,0,0,0,0,0,0,0,0] 遍历列表2，把列表1里面数字的位置变为1，然后查找直接对比对应下标的数字，0表示不存在，1表示存在 Python写法 list1 = [2, 3, 6, 7, 8, 9] list2 = [0, 0, 0, 0, 0, 0, 0, 0...
算法与数据结构详解：C语言中的时间空间复杂度与基本操作
首先，我们来探讨算法的复杂度，包括时间复杂度和空间复杂度。 时间复杂度是衡量一个算法执行效率的重要指标，它描述了随着输入数据规模的增长，算法运行所需时间的增长速度。算法的时间复杂度通常用大O记号表示，...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值