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

程序员老茶

已于 2023-02-16 15:37:42 修改

阅读量204

点赞数 1

分类专栏：数据结构与算法文章标签：排序算法算法数据结构 c语言开发语言

于 2023-02-16 15:36:45 首次发布

本文链接：https://blog.csdn.net/qq_53431712/article/details/129063140

版权

数据结构与算法专栏收录该内容

10 篇文章 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");
}