排序算法（C语言实现）

最新推荐文章于 2022-08-08 14:18:45 发布
最新推荐文章于 2022-08-08 14:18:45 发布
阅读量182 收藏
点赞数 1
文章标签： 算法 排序算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cl18154399536/article/details/104985394
版权

一、直接插入排序

直接插入排序：是一种最简单的排序方法，是插入排序的一种。
插入排序的基本思想是：在一个已经排好序的记录序列的基础之上，每次将一个待排序的记录有序地插入到已经排好序的记录序列之中，直到将所有待排序记录全部插入为止。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};

void Creat(struct SortTable *S)
{
	int i;
	printf("请输入待排序元素个数（<=30）:");
	scanf("%d",&S->length);
	printf("请输入元素：\n");
	for(i=1;i<=S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}

void Sort(struct SortTable *S)//插入排序算法
{
	int i,j;
	for(i=2;i<=S->length;i++)
	{
		if(S->data[i] < S->data[i-1])
		{
			S->data[0]=S->data[i];
			j=i-1;
			while(S->data[0]<S->data[j])
			{
				S->data[j+1] = S->data[j];
				j--;
			}
		}
		S->data[j+1]=S->data[0];
	}
}

void Print(struct SortTable *S)
{
	int i;
	printf("排序后:\n");
	for(i=1;i<=S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S);
	Print(&S);
}

二、希尔排序

希尔排序：又称为缩小增量排序，因D.L.Shell与1959年提出而得名，是插入排序的一种。
希尔排序的基本思想：先取一个小于n的整数di为第一个增量，把全部记录分为d1个组，所有距离d1倍数的记录放在同一组中，在各组中进行直接插入排序；然后，取第二个增量d2<d1，重复上述分组和排序，直至所取的增量为dt=1（dt<dt-1<…<d2<d1)，即所有记录放在同一组中进行直接插入排序。
平均时间复杂度：O(n^1.3)
最坏时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};
int d[4]={5,3,1,0};
void Creat(struct SortTable *S)
{
	int i;
	printf("请输入待排序元素个数（<=30）:");
	scanf("%d",&S->length);
	printf("请输入元素：\n");
	for(i=1;i<=S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}

void Sort(struct SortTable *S,int d[])//希尔排序算法
{
	int i,j,di,k=0;
	do
	{
		di=d[k];
		for(i=di+1;i <= S->length;i++)
			if(S->data[i] < S->data[i-di])
			{
				S->data[0]=S->data[i];
				for(j=i-di;j>0 && S->data[0]<S->data[j];j=j-di)
				{
					S->data[j+di]=S->data[j];
				}
				S->data[j+di]=S->data[0];
			}
		k++;
	}while(di>1);
	
}

void Print(struct SortTable *S)
{
	int i;
	printf("排序后:\n");
	for(i=1;i<=S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S,d);
	Print(&S);
}

三、冒泡排序

冒泡排序：是交换排序中最简单的一种。
冒泡排序的基本思想：首先将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序，则交换两个记录，然后比较第二个记录和第三个记录的关键字，依此类推，直至比较低n-1个记录和第n个记录的关键字为止。上述过程为第一趟冒泡排序，其结果使关键字最大的记录被安置到最后一个记录的位置上，然后进行第二趟冒泡排序，对其n-1个记录进行同样的操作，其结果使关键字次大的记录被安置到第n-1个记录的位置上。依此类推，直至整个序列有序位置。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};

void Creat(struct SortTable *S)
{
	int i;
	printf("请输入长度（<=30）:");
	scanf("%d",&S->length);
	printf("请输入数据：\n");
	for(i=0;i<S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}

void Sort(struct SortTable *S)
{
	int i,j,t;
	for(i=0;i<S->length;i++)
	{
		for(j=0;j<S->length-i-1;j++)
		{
			if(S->data[j]>S->data[j+1])
			{
				t=S->data[j+1];
				S->data[j+1]=S->data[j];
				S->data[j]=t;
			}
		}
	}
}

void Print(struct SortTable *S)
{
	int i;
	printf("排序后:\n");
	for(i=0;i<S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S);
	Print(&S);
}

四、快速排序

快速排序：是交换排序的一种。
快速排序的基本思想：以某个记录为基准，通过一趟排序将待排序列分割为独立的两部分，其中第一部分所有记录的关键字均小于或等于基准记录的关键字，后一部分所有记录的关键字均大于或等于基准记录的关键字。将待排序列按关键字以基准记录分成两部分的过程，称为第一次划分。对各部分不断划分，直到整个序列按关键字有序排列。
平均时间复杂度：O(nlogn)
最坏时间复杂度：O(n^2)
空间复杂度：O(logn)
稳定性：不稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};

void Creat(struct SortTable *S)
{
	int i;
	printf("请输入待排序元素个数（<=30）:");
	scanf("%d",&S->length);
	printf("请输入元素：\n");
	for(i=1;i<=S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}

int Partition(struct SortTable *S,int low,int high)//按基准进行分区
{
	int i,j;
	i=low,j=high;
	S->data[0]=S->data[i];//暂存基准记录
	while(i<j)
	{
		while(i<j && S->data[j]>S->data[0])//j向左扫描
			j--;
		S->data[i]=S->data[j];//将关键字小于基准的记录移动到基准前面
		while(i<j && S->data[i] <= S->data[0])//i向右扫描
			i++;
		S->data[j]=S->data[i];	//将关键字大于基准的记录移动到基准后面
	}
	S->data[j]=S->data[0];//基准记录最终存放位置
	return i;
}
void Sort(struct SortTable *S,int low,int high)//快速排序算法
{
	int u;
	if(low<high)
	{
		u=Partition(S,low,high);
		Sort(S,low,u-1);//对左子表进行递归排序
		Sort(S,u+1,high);//对右子表进行递归排序
	}
}

void Print(struct SortTable *S)
{
	int i;
	printf("排序后:\n");
	for(i=1;i<=S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S,1,S.length);
	Print(&S);
}

五、简单选择排序

简单选择排序：是一种简单的选择排序。
简单选择排序的基本思想：第一趟从所有的n个记录中，通过顺序比较各关键字的值，选取关键字值最小的记录与第一个记录交换；第二趟从剩下的n-1个记录中选取关键字值最小的记录与第二个记录交换，依此类推，第i趟排序从剩下的n-i个记录中选取关键字最小的记录，与第i个记录交换；经过n-1趟排序后，整个序列就成为了有序序列。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
空间复杂度：O(1)
稳定性：不稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};

void Creat(struct SortTable *S)
{
	int i;
	printf("请输入待排序元素个数（<=30）:");
	scanf("%d",&S->length);
	printf("请输入元素：\n");
	for(i=1;i<=S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}

void Sort(struct SortTable *S)
{
	int i,j,k,d;
	for(i=1;i<S->length;i++)
	{
		k=i;
		for(j=i+1;j<=S->length;j++)
		{
			if(S->data[j]<S->data[k])
				k=j;
		}
		if(k!=i)
		{
			S->data[0] = S->data[i];
			S->data[i] = S->data[k];
			S->data[k] = S->data[0];
		}
		printf("\n第%d趟排序结果:",i);
		for(d=1;d<=S->length;d++)
		{
			printf("%4d",S->data[d]);
		}
	}
}

void Print(struct SortTable *S)
{
	int i;
	printf("\n最终排序后:");
	for(i=1;i<=S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S);
	Print(&S);
}

六、堆排序

堆排序：是选择排序的一种。
堆排序的基本思想：有n个记录，首先将这n个记录按关键字建成堆，将堆顶元素输出，得到n个记录中关键字最小（或最大）的记录，将剩下的n-1个记录建成堆，输出堆顶元素，得到n个记录中关键字次小（或次大）的记录，如此反复，便得到一个按关键字有序排列的序列。
平均时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
空间复杂度：O(1)
稳定性：不稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};

void Creat(struct SortTable *S)
{
	int i;
	printf("请输入待排序元素个数（<=30）:");
	scanf("%d",&S->length);
	printf("请输入元素：\n");
	for(i=1;i<=S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}

void sift(struct SortTable *S,int k,int m)//调整堆算法
{
	int i,j;
	i=k;
	j=2*i;
	S->data[0] = S->data[i];
	while(j<=m)
	{
		if(j<m && S->data[j]<S->data[j+1])
			j++;
		if(S->data[0]<S->data[j])
		{
			S->data[i]=S->data[j];
			i=j;
			j=2*i;
		}
		else
			break;
	}
	S->data[i]=S->data[0];
}

void Sort(struct SortTable *S)//堆排序算法
{
	int k,i;
	int w;
	for(k=S->length/2;k>=1;k--)
		sift(S,k,S->length);
	printf("\n初始堆：");
	for(i=1;i<=S->length;i++)
		printf("%4d",S->data[i]);
	for(k=S->length;k>=2;k--)
	{
		w=S->data[k];
		S->data[k]=S->data[1];
		S->data[1]=w;
		sift(S,1,k-1);
	}

}

void Print(struct SortTable *S)
{
	int i;
	printf("\n排序后:");
	for(i=1;i<=S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S);
	Print(&S);
}

七、归并排序

归并排序：是将一个无序序列通过一系列合并产生一个有序序列，是利用“归并”技术来实现的。归并是指将若干个已经排好序的序列合并成一个有序序列。
归并排序的基本思想：设两个有序地子文件放在同一向量中相邻的位置r[low…m]和r[m+1…high]上，先将它们合并到一个局部暂存向量R1中。合并过程中，设置i，j，p三个指针，其初值分别指向这三个记录区的起始位置。合并时依次比较r[i]个r[j]的关键字，取关键字小小的记录复制到R1[p]中，然后将复制记录的指针i或j加1，且将指向复制位置的指针p加1。重复这一过程直至两个有序的子文件中有一个已经全部复制完毕为止，此时将另一个非空子文件的剩余记录依次复制到R1中。待合并完成后，将R1复制到r[low…high]中。
平均时间复杂度：O(nlogn)
最坏时间复杂度：O(nlogn)
空间复杂度：O(n)
稳定性：稳定

#include <stdio.h>
#define MAXSIZE 30
struct SortTable
{
	int length;
	int data[100];
};

void Creat(struct SortTable *S)
{
	int i;
	printf("请输入待排序元素个数（<=30）:");
	scanf("%d",&S->length);
	printf("请输入元素：\n");
	for(i=1;i<=S->length;i++)
	{
		scanf("%d",&S->data[i]);
	}
}
void Merge(struct SortTable *S,int low,int high,int m)
{
	int temp[100];//temp为临时数组，存放待排序的元素
	int i,j,k;
	for(i=low;i <= high;i++)
	{
		temp[i] = S->data[i];
	}
	i=low;j=low+m;k=low;
	while(i<low+m && j<=high)
	{
		if(temp[i] <= temp[j])
		{
			S->data[k++] = temp[i++];
		}
		else
		{
			S->data[k++] = temp[j++];
		}
	}
	if(i >= low+m)
	{
		while(j <= high)
			S->data[k++] = temp[j++];
	}
	else
	{
		while(i < low+m)
			S->data[k++] = temp[i++];
	}
}

void Sort(struct SortTable *S)//归并排序算法
{
	int length,low,high;
	low = 1;
	length = 1;
	while(length < S->length)
	{
		high = (S->length < low+2*length-1) ? S->length:low+2*length-1;
		Merge(S,low,high,length);
		if(high + length < S->length)
			low = high + 1;
		else
		{
			length = length * 2;
			low = 1;
		}

	}

}

void Print(struct SortTable *S)
{
	int i;
	printf("\n最终排序后:");
	for(i=1;i<=S->length;i++)
	{
		printf("%4d",S->data[i]);
	}
	printf("\n");
}

void main()
{
	struct SortTable S;
	Creat(&S);
	Sort(&S);
	Print(&S);
}
_wish_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
五种经典排序算法C++实现及总结
Bobhu1995的博客
10-27 352
1、冒泡排序（交换排序，稳定） 冒泡排序（Bubble Sort）,它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。 1.1 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数...
c语言利用max排序,C语言基础---回调函数和实现对任意数组进行排序
weixin_39806413的博客
05-20 255
版权声明：本文为小斑马伟原创文章，转载请注明出处！#define _CRT_SECURE_NO_WARNINGS#include#include#includevoid selectSort(void * arr, int eleSize, int len, int(*myCompare)(void*,void*)){char* temp = malloc(eleSize);for (int i ...
排序算法实现c语言
ALiangJie的博客
10-18 133
常见排序算法代码实现c语言 学习数据结构常见排序算法代码实现记录 包括常见三大类排序算法实现 选择排序：简单选择排序，堆排序 插入排序：简单插入排序，希尔排序 交换排序：冒泡排序，两端冒泡排序，快速排序 归并排序 基数排序 代码如下 ...
c语言实现各种排序,c语言实现各种排序算法
weixin_39852647的博客
05-19 73
以下是我用c语言实现的各种排序算法#pragmaonce;#defineMAXSIZE20000typedefintKeyType;typedefcharInfomation;typedefintLESSTNAN;typedefintShellData[];staticconstcharinfo='0';#ifndef_SDTLIB_H#define_STDLIB_...
常见的排序算法原理及c代码实现
小罗的博客
10-17 311
排序算法
常用排序算法C语言实现
03-10
本资源"常用排序算法C语言实现"提供了一个实践平台，帮助学习者将理论知识转化为实际代码。 首先，让我们探讨几种常见的排序算法及其C语言实现： 1. **冒泡排序（Bubble Sort）**：冒泡排序是最基础的排序方法，...
快速排序算法C语言实现与优化.pdf
最新发布
06-24
本文将详细介绍快速排序算法的C语言实现，并探讨其优化策略。 一、快速排序算法的基本原理 快速排序算法的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分的所有记录比另一部分的所有记录都要小...
堆排序算法 C语言实现
07-17
C语言实现的堆排序算法。 提供了堆排序算法的一个接口，可以为其它功能提供功能。
链表、图、排序算法C语言实现.zip
06-13
本资源"链表、图、排序算法C语言实现.zip"包含的是用C语言编写的链表、图以及排序算法的实现代码，这对于学习和理解这些概念提供了实际操作的例子。 首先，我们来详细探讨一下链表。链表是一种线性数据结构，与数组...
堆排序算法c语言实现
10-25
学习堆排序时自己编的代码，里面有自动生成随机数的代码段方便大家测试
排序算法的实现c语言,典型排序算法（C语言实现）
weixin_33212263的博客
05-23 362
《数据结构(C语言版)》的最后一次实验作业(排序)，要求如下：数据结构实验5：排序 要求： 1、直接插入排序； 2、shell 排序； 3、简单选择排序； 4、快速排序； 5、堆排序(选做)； 分享一下我(@ tongtongxyz)的小作业吧。/**************************************** Filename: sort.cpp ...
数据结构之各种排序方式:直接插入，希尔，直接选择，冒泡，归并，计数，快速排序三种方式
qq1024734546的博客
08-02 756
1.排序的概念 稳定性： 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次 序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排 序算法是稳定的；否则称为不稳定的。 内部排序： 数据元素全部放在内存中的排序。 外部排序： 数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存...
C++ multimap
weixin_45743799的博客
03-17 7360
multimap 是关联容器的一种，multimap 的每个元素都分为关键字和值两部分，容器中的元素是按关键字排序的，并且允许有多个元素的关键字相同。 注意：不能直接修改 multimap 容器中的关键字。因为 multimap 中的元素是按照关键字排序的，当关键字被修改后，容器并不会自动重新调整顺序，于是容器的有序性就会被破坏，再在其上进行查找等操作就会得到错误的结果。 使用 multimap ...
数据结构-排序算法（c语言实现篇）
CHAKMING1的博客
08-08 8811
数据结构中最全的排序算法（C语言实现）
八大排序算法—源代码(c语言)
Brant_zero的博客
07-15 2950
插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法，插入排序 希尔排序 选择排序 堆排序 冒泡排序 快速排序 归并排序 计数排序八大排序算法的C语言实现。...
C语言算法实现选择排序
apple_60666910的博客
12-25 7043
一、选择排序（Selection sort）是一种简单直观的排序算法，且是一种不稳定的排序方法。 二、选择排序（Selection sort）的实现原理： 排序的一组数中，选出最小（或最大）的一个数与第一个位置的数交换；在剩下的数当中找最小的与第二个位置的数交换，即顺序放在已排好序的数列的最后，如此循环，直到全部数据元素排完为止。 三、选择排序（Selection sort）的算法分析： 对于选择排序首先要理解选择排序的思想，程序中会用到两个for循环，一个for循环用来输入值，确定数据元素的位置.
c语言选择排序法程序设计,C语言选择排序算法及实例代码
weixin_30921373的博客
05-17 1437
选择排序是排序算法的一种，这里以从小到大排序为例进行讲解。基本思想及举例说明选择排序(从小到大)的基本思想是，首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，直到所有的数从小到大排序。在实现上，我们通常是先确定第i小的数所在的位置，然后，将其与第i个数进行交换。下面，以对 3 2 4 1 进行选择排序说明排序过程，使用min_index 记录当前最小的数所...
C语言实现排序算法
weixin_54792212的博客
04-07 2854
前言 这里实现几种常见的排序算法： 一、插入排序 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 1.1 直接插入排序 当插入第i个元素时，前面的i个元素已经排好序，此时array[i]与array[i-1],array[i-2],…进行比较，找到插入位置将array[i]插入，原来位置上的元素顺序后移 具体代码实现： typedef int ISType; void InsertSort(ISType* nums, int siz
经典排序算法——选择排序（python代码实现）
记录知识，学习分享
06-10 5817
选择排序是一种十分基础的的排序算法，比较简单直观。当对数据量较少的序列实现升序或降序排序是可以采用选择排序。 从头到尾扫描所有的n个元素，从中找出最小或最大的元素并和第一个元素进行交换，然后从除第一个以外的n-1个元素中扫描，找出最小或最大的元素并和第一个（n-1个中）元素进行交换，不断迭代此操作剩下的元素，最终就是一个有序的序列。性能特点待排序列：升序排序 第一趟排序：待排序列中1为最小元素，且1本来就在最小元素位置，则不发生元素交换。第二趟排序：剩下待排序列中4为最小元素，则把4交换到最小
冒泡排序算法c语言实现
03-23
以下是冒泡排序的C语言实现： ```c #include void bubbleSort(int arr[], int n) { for (int i = 0; i ; i++) { for (int j = 0; j ; j++) { if (arr[j] > arr[j+1]) { // 交换相邻元素的位置 int temp = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值