数据结构（C语言版）八大排序算法

nchu可乐百香果

已于 2024-01-12 15:38:13 修改

阅读量377

点赞数 9

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

于 2024-01-06 21:55:26 首次发布

本文链接：https://blog.csdn.net/m0_74216612/article/details/135429511

版权

数据结构C语言版专栏收录该内容

3 篇文章 0 订阅

订阅专栏

先写顺序表的存储结构：

#define Maxsize 50
#include "stdlib.h"
#include "stdio.h"
#include "time.h" 
typedef int ElemType;
typedef struct{
	ElemType key;
}RedType;
typedef struct {
	RedType *r;
	int length;
}Sqlist,HeapType;

接下来就是各大排序算法的代码了；

1.直接插入排序

//直接插入排序 
void InsertSort(Sqlist &L){
	int i,j;
	for(i=2;i<=L.length;i++){
		L.r[0]=L.r[i];
		for(j=i-1;j>0&&(L.r[0].key<L.r[j].key);j--)
			L.r[j+1]=L.r[j];
		L.r[j+1]=L.r[0];
	}
}

2.折半插入排序

//折半插入排序
void BInsertSort(Sqlist &L){
	int i,j,low,high,mid;
	for(i=2;i<=L.length;i++){
		L.r[0]=L.r[i];
		low=1;high=i-1;
		while(low<=high){
			mid=(low+high)/2;
			if(L.r[0].key<L.r[mid].key) high=mid-1;
			else low=mid+1;
		}//while
		for(j=i-1;j>=high+1;j--) L.r[j+1]=L.r[j];//记录后移
		L.r[high+1]=L.r[0];                      //插入 	
	}
}

3.希尔插入排序

//希尔插入排序 
void ShellInsert(Sqlist &L,int dk){
	int i,j;
	for(i=1+dk;i<=L.length;i++){
		L.r[0]=L.r[i];
		for(j=i-dk;j>0&&(L.r[0].key<L.r[j].key);j-=dk)
			L.r[j+dk]=L.r[j];
		L.r[j+dk]=L.r[0];
	}
}
void ShellSort(Sqlist &L,int dlta[],int t){
	int len=L.length;
	int dk; 
	for(dk=len/2;dk>=1;dk/=2){
		ShellInsert(L,dk);
	}
}

4.冒泡排序

5.直接选择排序

//冒泡排序
void swap(int *a,int *b){
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}
void BubbleSort(Sqlist &L){
	int i,j;
	for(i=1;i<=L.length-1;i++){
		for(j=1;j<=L.length-i;j++){
			if(L.r[j].key>L.r[j+1].key) swap(&L.r[j].key,&L.r[j+1].key);
		}
	}
}
//直接选择排序 
void SelectSort(Sqlist &L){
	int i,j,min;
	for(i=1;i<=L.length-1;i++){
		min=i;
		for(j=i+1;j<=L.length;j++){
			if(L.r[j].key<L.r[min].key) min=j;
		}
		if(min!=i) swap(&L.r[i].key,&L.r[min].key);
	}
}

6.快速排序

//快速排序
int Partition(Sqlist &L,int low,int high){
	int pkey;//pivotkey
	L.r[0]=L.r[low];
	pkey=L.r[low].key;
	while(low<high){
		while(low<high&&L.r[high].key>=pkey) --high;
		L.r[low]=L.r[high];
		while(low<high&&L.r[low].key<=pkey) ++low;
		L.r[high]=L.r[low];	
	}
	L.r[low]=L.r[0];
	return low;
} 
void QuickSort(Sqlist &L,int low,int high){
	int pkey;
	if(low<high){
		pkey=Partition(L,low,high);
		QuickSort(L,low,pkey-1);
		QuickSort(L,pkey+1,high);
	}
}

7.堆排序

//堆排序
void HeapAdjust(Sqlist &H, int s, int m) {
	int i,j;
    RedType rc = H.r[s];
	for (j=2*s; j<=m; j*=2) { //沿key较大的孩子结点向下筛选,j为key较大的记录的下标 
		if (j<m&&(H.r[j].key<H.r[j+1].key))
           ++j;
		if (rc.key>=H.r[j].key) 
           break; //rc应插入在位置s上
		H.r[s]=H.r[j]; s=j;
	}
	H.r[s] = rc; //插入
}//HeapAdjust 
void HeapSort (HeapType &H){ //对顺序表H进行堆排序。
	int i;
	int len=H.length;
	for(i=len/2; i>0; --i) 
		HeapAdjust(H,i,H.length);
	for(i=len; i>1; --i){ 
		swap(&H.r[1].key,&H.r[i].key); 
		HeapAdjust(H, 1, i-1 ); //将H.R[1..i-1]重新调整为大顶堆
	}
}//HeapSort

8.二路归并排序

//归并排序

void merge(int* a, int low, int mid, int high)  //合并函数
{
	int* b = new int[high - low + 3];  //用 new 申请一个辅助函数
	int i = low, j = mid + 1, k = 1;    // k为 b 数组的小标
	while (i <= mid && j <= high)  
	{
		if (a[i] <= a[j])
		{
			b[k++] = a[i++];  //按从小到大存放在 b 数组里面
		}
		else
		{
			b[k++] = a[j++];
		}
	}
	while (i <= mid)  // j 序列结束，将剩余的 i 序列补充在 b 数组中 
	{
		b[k++] = a[i++];
	}
	while (j <= high)// i 序列结束，将剩余的 j 序列补充在 b 数组中 
	{
		b[k++] = a[j++];
	}
	k = 1;  //从小标为 0 开始传送
	for (int i = low; i <= high; i++)  //将 b 数组的值传递给数组 a
	{
		a[i] = b[k++];
	}
//	delete[]b;     // 辅助数组用完后，将其的空间进行释放（销毁）
}
void MSort(int *a, int low, int high) //归并排序
{
	if (low < high)
	{
		int mid = (low + high) / 2;
		MSort(a, low, mid);          //对 a[low,mid]进行排序
		MSort(a, mid + 1, high);    //对 a[mid+1,high]进行排序
		merge(a, low, mid, high);       //进行合并操作
	}
}
void MergeSort(Sqlist &L){
	int a[L.length+1];
	for(int i=1;i<=L.length;i++) a[i]=L.r[i].key;
	MSort(a,1,L.length);
	for(int i=1;i<=L.length;i++) L.r[i].key=a[i];
}

这是完整的代码

#define Maxsize 50
#include "stdlib.h"
#include "stdio.h"
#include "time.h" 
typedef int ElemType;
typedef struct{
	ElemType key;
}RedType;
typedef struct {
	RedType *r;
	int length;
}Sqlist,HeapType;
//typedef Sqlist HeapType;
void InsertSort(Sqlist &L);//直接插入排序
void BInsertSort(Sqlist &L); //折半插入排序
void ShellInsert(Sqlist &L,int dk);
void ShellSort(Sqlist &L,int dlta[],int t);//希尔插入排序 
void swap(int *a,int *b);
void BubbleSort(Sqlist &L);//冒泡排序
void SelectSort(Sqlist &L);//直接选择排序 
int Partition(Sqlist &L,int low,int high);
void QuickSort(Sqlist &L,int low,int high);//快速排序
void HeapAdjust(Sqlist &H, int s, int m);//堆排序
void HeapSort (HeapType &H);
void merge(int* a, int low, int mid, int hight);//归并排序
void MSort(int* a, int low, int hight);
void MergeSort(Sqlist &L);
//直接插入排序 
void InsertSort(Sqlist &L){
	int i,j;
	for(i=2;i<=L.length;i++){
		L.r[0]=L.r[i];
		for(j=i-1;j>0&&(L.r[0].key<L.r[j].key);j--)
			L.r[j+1]=L.r[j];
		L.r[j+1]=L.r[0];
	}
}
//折半插入排序
void BInsertSort(Sqlist &L){
	int i,j,low,high,mid;
	for(i=2;i<=L.length;i++){
		L.r[0]=L.r[i];
		low=1;high=i-1;
		while(low<=high){
			mid=(low+high)/2;
			if(L.r[0].key<L.r[mid].key) high=mid-1;
			else low=mid+1;
		}//while
		for(j=i-1;j>=high+1;j--) L.r[j+1]=L.r[j];//记录后移
		L.r[high+1]=L.r[0];                      //插入 	
	}
} 
//希尔插入排序 
void ShellInsert(Sqlist &L,int dk){
	int i,j;
	for(i=1+dk;i<=L.length;i++){
		L.r[0]=L.r[i];
		for(j=i-dk;j>0&&(L.r[0].key<L.r[j].key);j-=dk)
			L.r[j+dk]=L.r[j];
		L.r[j+dk]=L.r[0];
	}
}
void ShellSort(Sqlist &L,int dlta[],int t){
	int len=L.length;
	int dk; 
	for(dk=len/2;dk>=1;dk/=2){
		ShellInsert(L,dk);
	}
}
//void ShellSort(Sqlist &L,int dlta[],int t){
//	int i;
//	for(i=0;i<t;i++){
//		ShellInsert(L,dlta[i]);
//	}
//}

//冒泡排序
void swap(int *a,int *b){
	int temp;
	temp=*a;
	*a=*b;
	*b=temp;
}
void BubbleSort(Sqlist &L){
	int i,j;
	for(i=1;i<=L.length-1;i++){
		for(j=1;j<=L.length-i;j++){
			if(L.r[j].key>L.r[j+1].key) swap(&L.r[j].key,&L.r[j+1].key);
		}
	}
}
//直接选择排序 
void SelectSort(Sqlist &L){
	int i,j,min;
	for(i=1;i<=L.length-1;i++){
		min=i;
		for(j=i+1;j<=L.length;j++){
			if(L.r[j].key<L.r[min].key) min=j;
		}
		if(min!=i) swap(&L.r[i].key,&L.r[min].key);
	}
}
//快速排序
int Partition(Sqlist &L,int low,int high){
	int pkey;//pivotkey
	L.r[0]=L.r[low];
	pkey=L.r[low].key;
	while(low<high){
		while(low<high&&L.r[high].key>=pkey) --high;
		L.r[low]=L.r[high];
		while(low<high&&L.r[low].key<=pkey) ++low;
		L.r[high]=L.r[low];	
	}
	L.r[low]=L.r[0];
	return low;
} 
void QuickSort(Sqlist &L,int low,int high){
	int pkey;
	if(low<high){
		pkey=Partition(L,low,high);
		QuickSort(L,low,pkey-1);
		QuickSort(L,pkey+1,high);
	}
}
//堆排序
void HeapAdjust(Sqlist &H, int s, int m) {
	int i,j;
    RedType rc = H.r[s];
	for (j=2*s; j<=m; j*=2) { //沿key较大的孩子结点向下筛选,j为key较大的记录的下标 
		if (j<m&&(H.r[j].key<H.r[j+1].key))
           ++j;
		if (rc.key>=H.r[j].key) 
           break; //rc应插入在位置s上
		H.r[s]=H.r[j]; s=j;
	}
	H.r[s] = rc; //插入
}//HeapAdjust 
void HeapSort (HeapType &H){ //对顺序表H进行堆排序。
	int i;
	int len=H.length;
	for(i=len/2; i>0; --i) 
		HeapAdjust(H,i,H.length);
	for(i=len; i>1; --i){ 
		swap(&H.r[1].key,&H.r[i].key); 
		HeapAdjust(H, 1, i-1 ); //将H.R[1..i-1]重新调整为大顶堆
	}
}//HeapSort

//归并排序

void merge(int* a, int low, int mid, int high)  //合并函数
{
	int* b = new int[high - low + 3];  //用 new 申请一个辅助函数
	int i = low, j = mid + 1, k = 1;    // k为 b 数组的小标
	while (i <= mid && j <= high)  
	{
		if (a[i] <= a[j])
		{
			b[k++] = a[i++];  //按从小到大存放在 b 数组里面
		}
		else
		{
			b[k++] = a[j++];
		}
	}
	while (i <= mid)  // j 序列结束，将剩余的 i 序列补充在 b 数组中 
	{
		b[k++] = a[i++];
	}
	while (j <= high)// i 序列结束，将剩余的 j 序列补充在 b 数组中 
	{
		b[k++] = a[j++];
	}
	k = 1;  //从小标为 0 开始传送
	for (int i = low; i <= high; i++)  //将 b 数组的值传递给数组 a
	{
		a[i] = b[k++];
	}
//	delete[]b;     // 辅助数组用完后，将其的空间进行释放（销毁）
}
void MSort(int *a, int low, int high) //归并排序
{
	if (low < high)
	{
		int mid = (low + high) / 2;
		MSort(a, low, mid);          //对 a[low,mid]进行排序
		MSort(a, mid + 1, high);    //对 a[mid+1,high]进行排序
		merge(a, low, mid, high);       //进行合并操作
	}
}
void MergeSort(Sqlist &L){
	int a[L.length+1];
	for(int i=1;i<=L.length;i++) a[i]=L.r[i].key;
	MSort(a,1,L.length);
	for(int i=1;i<=L.length;i++) L.r[i].key=a[i];
}

void create_srand(Sqlist &L){
	L.r=(RedType *) malloc(sizeof (RedType)*(20000));
    printf("请输入您想要的数据大小（1-20000）：\n");
    scanf("%d", &L.length);
    for(int i=1;i<=L.length;i++)
        L.r[i].key=10000+rand()%20000;//10000--29999 
	
}


void Create_Sqlist(Sqlist &L)
{
	L.r=(RedType *) malloc(sizeof (RedType)*(Maxsize+1));
    printf("请给顺序表赋值：\n");
    printf("你要输入几个数据：\n");
    scanf("%d", &L.length);
    printf("请依此输入这几个元素：\n");
    for(int i=1;i<=L.length;i++)
        scanf("%d", &L.r[i].key);
    printf("输入完毕!\n");
}
void Print(Sqlist L){
	printf("顺序表为:\n");
	for(int i=1;i<=L.length;i++){
		printf("%d ",L.r[i].key);
	}
}
int main(){
	srand((unsigned)time(NULL));
	double during_s,during_ms;
	clock_t start,finish;
	int a[3]={3,2,1};
	int t=3;
	Sqlist L;
//	Create_Sqlist(L);
	create_srand(L);
	Print(L);
	printf("\n1.直接插入排序		\n");
	printf("2.中间插入排序		\n");
	printf("3.希尔排序		\n");
	printf("4.冒泡排序		\n");
	printf("5.快速排序		\n");
	printf("6.选择排序		\n");
	printf("7.堆排序		\n");
	printf("8.归并排序		\n");
	int flag=1;
	int n;
	printf("\n请输入您的选择:");
	scanf("%d",&n);
	while(flag) {
		switch (n){ 
		case 1:start=clock();InsertSort(L);finish=clock();flag=0;break;
		case 2:start=clock();BInsertSort(L);finish=clock();flag=0;break;
		case 3:start=clock();ShellSort(L,a,t);finish=clock();flag=0;break;
		case 4:start=clock();BubbleSort(L);finish=clock();flag=0;break;
		case 5:start=clock();QuickSort(L,1,L.length);finish=clock();flag=0;break;
		case 6:start=clock();SelectSort(L);finish=clock();flag=0;break;
		case 7:start=clock();HeapSort(L);finish=clock();flag=0;break;
		case 8:start=clock();MergeSort(L);finish=clock();flag=0;break;
		default:{printf("输入错误，请重新输入！\n");
				printf("\n请输入您的选择:");
				scanf("%d",&n);break;
				break;
			}//default
		}//switch
	}//while
//		printf("\n排序后：\n");
//		Print(L);
		during_s=(double)(finish-start)/CLK_TCK;
		during_ms=during_s*1000;
//		printf("\n 运行时间为:%lf 秒",during_s);
		printf("\n 运行时间为:%lf 毫秒\n",during_ms);
	
}

整个文章大概就是这样了，这是我第一次写CSDN博客，如果有哪里写的不太好的请指正，谢谢大家！