数据结构与算法-排序的操作及应用C语言实现（超详细注释/设计/实验/作业）

已于 2023-02-16 15:37:42 修改
阅读量201 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 排序算法 算法 数据结构 c语言 开发语言
于 2023-02-16 15:36:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53431712/article/details/129063140
版权

目录

一、引言

感谢宝子们一键三连支持，火速更新中~~
本章介绍了排序的十大算法，包括直接插入排序，希尔子排序，希尔排序，冒泡排序，快速排序，直接选择排序，堆排序，归并子排序，归并排序，基数排序。

二、目的

  1. 掌握图的存储结构
  2. 掌握各种常用排序的算法
  3. 掌握各种排序方法的异同点
  4. 掌握各种排序方法的时间复杂度和空间复杂度
  5. 掌握各种算法是否是稳定的

三、环境与设备

操作系统:Windows 10
编译器:Visual Studio 2021

四、存储结构

typedef int KeyType;
typedef struct{
	KeyType key;
}RecType;
RecType data[MAX+1];

五、函数

1.	void DirectInsertSort(int data[],int n)//直接插入排序
2.	void SCSort(int data[],int n,int start,int step)//希尔子排序
3.	void ShellSort(int data[],int n)//希尔排序
4.	void BubbleSort(int data[],int n)//冒泡排序
5.	void QuickSort(int data[],int start,int end)//快速排序
6.	void QirectSelectSort(int data[],int n)//直接选择排序
7.	void HeapSort(int data[],int n)//堆排序
8.	void MergCSort(int data[],int n,int start)//归并子排序
9.	void MergSort(int data[],int n)//归并排序
10.	void output(int data[],int n)//输出数据
11.	void inputdata(int data[],int *n)//输入数据
12.	void BSort()//基数排序

六、核心代码

#include<stdio.h>
#include<stdlib.h> 
#define MAX 20
typedef int KeyType;
typedef struct{
	KeyType key;
}RecType;
RecType data[MAX+1];
void DirectInsertSort(RecType data[],int n);//直接插入排序
void SCSort(RecType data[],int n,int step);//希尔子排序
void ShellSort(RecType data[],int n,int step);//希尔排序
void BubbleSort(RecType data[],int n);//冒泡排序
int QuickSort(RecType data[],int start,int end);//快速排序
void Qsort(RecType data[],int low,int high);
void Quickmain(RecType data[],int n);
void QirectSelectSort(RecType data[],int n);//直接选择排序
void Blnsertsort(RecType data[],int n);//折半插入排序 
void HeapSort(RecType data[],int n);//堆排序
void HeapAdjust(RecType data[],int s,int n);//堆子排序
void MergCSort(RecType data[],int low,int mid,int high);//归并子排序
void MergSort(RecType data[],int low,int high);//归并排序
void BSort(RecType data[],int n,int w);//基数排序
int Init();
void menu1(); 
void Output(int n);
void menu();
int main()
{
	
	menu();
} 
int Init()
{
	int x=1,i=1;
	printf("请输入需要排序的值-1结束输入\n");
	scanf("%d",&x);
	while(x!=-1)
	{
		data[i].key=x;
		scanf("%d",&x);
		i++;
	}
	return i-1;
}
void Output(int n)
{
	printf("排序成功\n");
	for(int i=1;i<=n;i++)
	{
		printf("%d\t",data[i].key);
	}
	printf("\n");
}
void DirectInsertSort(RecType data[],int n)//直接插入排序
{
	int i,j;
	for(i=2;i<=n;i++)
	{
		if(data[i].key<data[i-1].key)
		{
			data[0].key=data[i].key;
		
			for(j=i-1;data[0].key<data[j].key;j--)
			{
				data[j+1].key=data[j].key;
			}
			data[j+1].key=data[0].key;
		}
	}
	
}
void SCSort(RecType data[],int n)//希尔子排序
{
	
	int increment=n;
	do
	{
		increment=increment/3+1;
		ShellSort(data,n,increment);
	}while(increment>1);
}
void ShellSort(RecType data[],int n,int step)//希尔排序
{
	int i,j;
	for(i=1+step;i<=n;i++)
	{
		if(data[i].key<data[i-step].key)
		{
			data[0].key=data[i].key;
			for(j=i-step;(j>0&&data[0].key<data[j].key);j=j-step)
			{
				data[j+step].key=data[j].key;
			}
			data[j+step].key=data[0].key;
		}
	}
}
void BubbleSort(RecType data[],int n)//冒泡排序
{
	int sign=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n-i;j++)
		{
			if(data[j].key>data[j+1].key)
			{
				KeyType temp;
				temp=data[j].key;data[j].key=data[j+1].key;data[j+1].key=temp;
				sign=1;
			}
		}
		if(!sign)
		{
			return ;
		}
	}
}
int QuickSort(RecType data[],int low,int high)//快速排序
{
	data[0]=data[low];
	while(low<high)
	{
		while(low<high&&data[high].key>=data[low].key)
		{
			high--;
		}
		data[low]=data[high];
		while(low<high&&data[low].key<=data[low].key)
		{
			low++;
		}
		data[high]=data[low];
	}
	data[low]=data[0];
	return low;
}
void Quickmain(RecType data[],int n)
{
	Qsort(data,1,n);
}
void Qsort(RecType data[],int low,int high)
{
	int pivot;
	pivot=QuickSort(data,low,high);
	if(low<high)
	{
		Qsort(data,pivot+1,high);
		Qsort(data,low,pivot-1);
	}
}
void QirectSelectSort(RecType data[],int n)//直接选择排序
{
	int k=1;
	for(int i=1;i<=n;i++)
	{
		k=i;
		for(int j=i+1;j<=n;j++)
		{
			if(data[k].key>data[j].key)
			{
				k=j;
			}	
		}	
		if(k!=i)
		{
			data[0]=data[k];data[k]=data[i];data[i]=data[0];
		}
	} 
}
void Blnsertsort(RecType data[],int n)//折半插入排序 
{
	int low,high,mid;
	for(int i=2;i<=n;i++)
	{
		data[0]=data[i];
		low=1,high=i-1;
		while(low<=high)
		{
			mid=(low+high)/2;
			if(data[0].key<data[mid].key)	high=mid-1;
			else low=mid+1;
		}
		for(int j=i-1;j>=high+1;j--)
		{
			data[j+1]=data[j];
		}
		data[high+1]=data[0];
	}
	
}

void HeapSort(RecType data[],int n)//堆排序
{
	int i;
	for(i=n/2;i>=1;i--)
	{
		HeapAdjust(data,i,n); 
	} 
	for(i=n;i>=1;i--)
	{
		printf("%d\t",data[1].key);
		data[1]=data[i];//最后结点赋值给根 
		HeapAdjust(data,1,i-1);//最后结点无需比较 
	}

}
void HeapAdjust(RecType data[],int s,int n)//堆排序
{
	data[0]=data[s];
	for(int j=s*2;j<=n;j*=2)
	{
		if(j<n&&data[j].key>data[j+1].key)	j++;
		if(data[0].key<=data[j].key)	break;
		data[s]=data[j];	s=j;
	} 
	data[s]=data[0];
}
void MergCSort(RecType data[],int low,int mid,int high)//归并子排序
{
	int i=low,j=mid+1,p=0;
	RecType* R1;
	R1=(RecType*)malloc((high-low+1)*sizeof(RecType));
	if(!R1)	return;
	while(i<=mid&&j<=high)
	{
		R1[p++]=(data[i].key<=data[j].key)?data[i++]:data[j++];
	}
	while(i<=mid)
	{
		R1[p++]=data[i++];
	}
	while(j<=high)
	{
		R1[p++]=data[j++];
	}
	for(p=0,i=low;i<=high;p++,i++)
	{
		data[i]=R1[p];
	}
}
void MergSort(RecType data[],int low,int high)//归并排序
{
	int mid;
	if(low<high)
	{
		mid=(high+low)/2;
		MergSort(data,low,mid);
		MergSort(data,mid+1,high); 
		MergCSort(data,low,mid,high);
	}
}
void BSort(RecType data[],int n,int w)//基数排序
{
	int b[10][n+1]={0};
	int d=1,x;
	int num=1;
	for(int q=1;q<=w;q++)
	{
		for(int i=0;i<10;i++)//清空桶 
		{
			for(int j=0;j<=n;j++)
			{
				b[i][j]=0;
			}
		}
		
		for(int i=1;i<=n;i++)
		{
			x=data[i].key/d%10;
			b[x][++b[x][0]]=data[i].key;//b[x][0]桶中有几个数 
		}
		num=1;
		for(int k=0;k<10;k++)
		{
			for(int j=1;j<=b[k][0];j++)
			{
				data[num++].key=b[k][j];
			}
		}
		d*=10;
	}
	
}
void menu()
{
	system("mode con cols=80 lines=45");
	system("color F4");
	printf("\t***************************************************************\n");
	printf("\t*                        排序                                 *\n");
	printf("\t***************************************************************\n");
	printf("\t*\t\t        1.直接插入排序                        *\n");
	printf("\t*\t\t        2.希尔排序                            *\n");
	printf("\t*\t\t        3.冒泡排序                            *\n");
	printf("\t*\t\t        4.快速排序                            *\n");
	printf("\t*\t\t        5.直接选择排序                        *\n");
	printf("\t*\t\t        6.堆排序                              *\n");
	printf("\t*\t\t        7.归并排序                            *\n");
	printf("\t*\t\t        8.基数排序                            *\n");
	printf("\t***************************************************************\n");
	printf("\t\t请选择功能\n");
	int n=0,i=1;
	int a;
	scanf("%d",&a);
	while(a)
	{
		switch(a)
		{
			case 1:{	
						n=Init();
						DirectInsertSort(data,n);
						Output(n);
						break;
				}
			case 2:{
						n=Init();
						SCSort(data,n);
						Output(n);
						break;
					}
					
			
			case 3:n=Init();BubbleSort(data,n);Output(n);break;
			case 4:n=Init();Quickmain(data,n);Output(n);break;
			case 5:n=Init();QirectSelectSort(data,n);Output(n);break;
			case 6:n=Init();HeapSort(data,n);break;
			case 7:n=Init();MergSort(data,1,n);Output(n);break;
			case 8: 
					{	
						n=Init();
						int w;
						printf("请输入最大位数\n");
						scanf("%d",&w);
						BSort(data,n,w);Output(n);break;
					}
			case 12: menu1();break; 
			default:printf("\t\t还在紧张创作中！！！敬请期待！！！\n");
		}
		printf("\t\t请选择功能\n");
		printf("\t\t温馨提示输入12可查看菜单\n");
		scanf("%d",&a);
		system("cls");
	} 
}
void menu1()
{
	system("mode con cols=80 lines=45");
	system("color F4");
	printf("\t***************************************************************\n");
	printf("\t*                        排序                                 *\n");
	printf("\t***************************************************************\n");
	printf("\t*\t\t        1.直接插入排序                        *\n");
	printf("\t*\t\t        2.希尔排序                            *\n");
	printf("\t*\t\t        3.冒泡排序                            *\n");
	printf("\t*\t\t        4.快速排序                            *\n");
	printf("\t*\t\t        5.直接选择排序                        *\n");
	printf("\t*\t\t        6.堆排序                              *\n");
	printf("\t*\t\t        7.归并排序                            *\n");
	printf("\t*\t\t        8.基数排序                            *\n");
	printf("\t***************************************************************\n");
	printf("\t\t请选择功能\n");
}

七、调试界面

在这里插入图片描述

八、总结

十大排序在数据结构中，重中之重，宝子们哈哈学习。

程序员老茶
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构课程设计----综合排序
wsswsswss123的博客
03-30 4258
《数据结构课程设计》报告 日期： 项目名称： 综合排序 一、项目简介和需求分析 排序（sorting是计箅机程序设计的一种重要操作，它的功能是将一组任意顺序数据元素（记录），根据某一个（或几个）关键字按一定的顺序里新排列成为有序的序列。由于待排序的记录数量不同，使得排序过程中涉及的存储器的不同，可将排序方法分为两大类：一类是内部排序，指的是待排序的记录存放在计算机随机存储器中进行的排序过程；另一类是外部排序，指的是待排序记录的数量很大，以致内存一次不能容纳全部记
数据结构的所有结构和排序算法简单理解有注释源码
05-22
本资源提供了数据结构的各种实现以及排序算法的源代码，全部基于C语言，非常适合初学者理解和学习。 1. **单链表**：在单链表中，每个节点包含一个数据元素和一个指向下一个节点的指针。`计算学生成绩_单链表.cpp`...
数据结构实验之排序算法及其应用【附代码&实验成果】
米莱虾
04-14 5346
一、实验目的 1）理解并掌握各种常用内部排序算法的基本概念、思想和方法。掌握常用内部排序算法流程。 2）掌握常用的排序方法，深刻理解排序的定义和各种排序方法的特点。 3）通过实验观察不同方法的不同之处，记录并分析各种排序方法的结果。 二、实验环境 1）自备计算机，windows操作系统以及相关的编译器（如Devc++）。 三、实验要求 1）理解及熟练运用直接插入排序、快速排序、堆排序和归并排序、哈希排序等内部排序算法。 2）通过计数统计各算法的关键字比较次数和关键字移动次数。 3）分析算法的时间复杂度、空间
【数据结构】——八大排序（详解+图+代码详解）看完你会有一个全新认识
m0_74092462的博客
04-12 1322
排序在生活中是非常重要的，所以排序在数据结构中也占有很大的地位，相信大家可能被这些排序弄得比较混淆或者对某个排序原理没有弄清，相信看完本篇会对你有所帮助！排序的概念与应用排序概念排序：排序就是使一串数据，按某个或者某些关键字的大小，递减或者递增排列起来的操作稳定性：在排序的过程中，可能存在两个或者以上的关键字相等的记录，排序的结果可能会不一样，这里就分成了稳定和不稳定。
数据结构-排序算法（C语言实现）
m0_69597277的博客
04-17 633
排序稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。编译环境：vs2013对于所有排序，统一以数组array[size-1]为待排序对象。
数据结构实验-排序算法的应用
qq_62899367的博客
11-15 460
数据结构实验-排序算法的应用。代码与课本稍有出入
常用排序
qq_43909184的博客
10-17 331
这期来说一说排序 直接插入排序 直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。 元素集合越接近有序，直接插入排序算法的时间效率越高 时间复杂度：O(N^2) 空间复杂度：O(1) 稳定性：稳定 void InsertSort(int* a, int n) { ass...
cpp-AlgorithmsC各种基础算法数据结构的C语言实现
08-16
"cpp-AlgorithmsC各种基础算法数据结构的C语言实现"是一个专注于C语言实现算法和数据结构的项目。这个项目可以帮助开发者深入理解算法和数据结构的工作原理，同时提升编程能力。 1. **基础算法**： - 排序算法：如...
C语言实现的冒泡排序算法
01-04
本资源不仅提供了冒泡排序的C语言代码实现，还通过详细的注释和逐步的解释，帮助读者理解每一步代码的含义和作用。此外，为了更好地帮助读者理解和应用这一算法，资源中还包含了几个实践示例和练习题。
基于C语言的堆排序算法（免费提供源码）
最新发布
06-21
通过C语言实现，用户可以深入理解堆排序的原理和实现过程，提升算法设计和编程能力。 堆排序是一种基于二叉堆数据结构的排序算法，具有时间复杂度为O(n log n)的优点，适用于大规模数据的排序。项目主要涵盖以下...
数据结构与算法全集（C源代码+详细注释）
11-27
全集内容结构如下： ├─图 │ ├─关键路径（有向无环图及其应用2） │ │ 1.txt │ │ ALGraph.cpp │ │ ALGraph.h │ │ CriticalPath.cpp │ │ CriticalPath.h │ │ InfoType.cpp │ │ InfoType.h │ │ ...
数据结构----排序算法总结与实现
gcj17829183701的博客
07-01 152
排序算法是数据结构的一个很重要的部分，目前最常用的排序算法有：冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、归并排序、快速排序、基数排序。下面将分别介绍这几种排序算法，并给出相应的代码实现。 1、冒泡排序 冒泡排序，即每次对比相邻两个元素，将大的元素向后移动，以从前向后冒泡为例子，第一循环结束，最大的元素会被移动到最后的位置，第二轮循环结束，次大（第二大）的元素会被移动到倒...
数据结构·排序
Yhan涵涵
06-11 564
排序：将一组杂乱无章的数据排列成一个按关键字有序的序列。关键字（key）：通常数据对象有多个属性域，即多个数据成员组成，其中有一个属性域可用来区分对象，该域即为关键字，作为排序依据。排序的主要目的：便于查找。排序算法的稳定性：数据集合中有Ri和Rj，它们的关键字相同Ki=Kj，排序前，Ri排在Rj前面，排序后，Ri仍在对象Rj前面，则该排序方法是稳定的，否则不稳定。内部排序和外部排序：内部排序：待排序记录存放在内存。外部排序：待排序记录一部分在内存，一部分在。
数据结构-排序
weixin_45476980的博客
04-09 549
关于 插入排序，选择排序 的复盘整理
数据结构—排序
AI_ELF的博客
09-10 1410
排序方法平均情况最好情况最坏情况辅助空间稳定性冒泡排序O(N2N^2N2O(N)O(N2N^2N2O(1)稳定简单选择排序O(N2N^2N2O(N2N^2N2O(N2N^2N2O(1)不稳定直接插入排序O(N2N^2N2O(N)O(N2N^2N2O(1)稳定希尔排序O(NlogNlogNlogN∽\backsim∽O(N2N^2N2O(N1.3N^{1.3}N1.3O(N2N^2N2O(1)
算法和数据结构的应用（'''排序算法的实现'''）
Mr.韩的博客
05-10 307
'''排序算法的实现''' import random def bubble_sort(L): '''冒泡排序的实现 O(n**2) 稳定算法 ''' for i in range(len(L)): for j in range(len(L) - i - 1): if L[j] &gt; L[j + 1]: ...
数据结构排序算法综合运用及比较（C语言实现）
qq_41519304的博客
04-29 9337
排序算法综合及效率比较 实验目的 实验内容 实验要求 实验步骤 概要设计 详细设计 软件测试 设计总结 源程序代码 1.实验目的 （1）熟练掌握几种经典排序的算法（如冒泡排序、选择排序、插入排序、希尔排序、折半插入排序、快速排序、归并排序、堆排序等）。培养综合运用所学知识，根据具体问题进行数据结构设计和算法设计的能力。 （2）熟练掌握简单的演示菜单与人机交互设计方法。 2.实验内容 （1）用r...
八大排序的实现及详解（c语言实现，基于leetcode的排序数组）
qq_45689158的博客
07-09 389
对于数据结构八大排序的理解，基于leetcode 排序数组的c语言实现
数据结构—八大排序
热门推荐
想要上进的coder的博客
01-09 3万+
一、直接插入排序 void InsertSort(int* a, int n) { assert(a); for (int i = 0; i < n - 1; ++i) { int end = i; int x=a[end+1];//将end后面的值保存到x里面了 //将x插入到[0，end]的有序区间 while (end >= 0) { if (a[end] > x) { a[end + 1] = a[end]; //往后挪动一位
“c++数据结构自设计算法可视化的实现”实验项目源代码
12-24
总的来说，“c 数据结构自设计算法可视化的实现”实验项目源代码将会是一个复杂而完整的C语言项目，涵盖了数据结构设计、算法实现和可视化界面设计等多个方面，是一个融合了理论与实践的综合性项目。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员老茶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值