linux下c语言的8种排序法

最新推荐文章于 2023-10-01 05:28:03 发布
原创 最新推荐文章于 2023-10-01 05:28:03 发布 · 494 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
Linux

当前文章被收录于：

Linux
51 篇文章 0 人学习
订阅专栏 查看详情
本文详细介绍了Linux下使用C语言实现的八种排序算法，包括快速排序、直接插入排序、希尔排序、简单选择排序、堆排序、冒泡排序、归并排序和基数排序。通过这些排序算法的实践，可以帮助开发者深入理解各种排序方法的原理和应用。
  1. 快速排序
  2. 直接插入排序
  3. 希尔排序
  4. 简单选择排序
  5. 堆排序
  6. 冒泡排序
  7. 归并排序
  8. 基数排序

1快速排序

#include <stdio.h>

void QuickSort(int *a, int start, int end)
{
	int x = start;
	int y = end;
	int base = a[x];

	if (x >= y)
	{
		return;
	}

	while (x < y)
	{
		while (a[y] > base && x < y)
		{
			y--;
		}
		if (x < y)
		{
			a[x++] = a[y];
		}
		while (a[x] < base && x < y)
		{
			x++;
		}
		if (x < y)
		{
			a[y--] = a[x];
		}
	}
	a[x] = base;

	QuickSort(a, start, x - 1);
	QuickSort(a, x + 1, end);
}

int main()
{
	int i;
	//int array[] = {4, 2, 7, 9, 0, 6, 2, 1, 8, 3};
	int array[100000] = {0};
	srand(time(NULL));
	for (i = 0; i < 100000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	QuickSort(array, 0, sizeof(array) / sizeof(array[0]) - 1);

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}

2直接插入排序

#include <stdio.h>

void InsertSort(int *a, int length)
{
	int i, j, tmp;

	for (i = 1; i < length; i++)
	{
		tmp = a[i];	
		for (j = i - 1; j >= 0; j--)
		{
			if (tmp < a[j])
			{
				a[j + 1] = a[j];
			}
			else
			{
				break;
			}
		}
		a[j + 1] = tmp;
	}
}

int main()
{
	int i;
	//int array[] = {4, 2, 7, 9, 0, 6, 2, 1, 8, 3};
	int array[10000] = {0};
	srand(time(NULL));
	for (i = 0; i < 10000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	InsertSort(array, sizeof(array) / sizeof(array[0]));

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}

3希尔排序

#include <stdio.h>

void InsertSort(int *a, int length)
{
	int i, j, tmp, h;

	for (h = length / 2; h > 0; h /= 2)
	{
		for (i = h; i < length; i++)   
		{
			tmp = a[i];	
			for (j = i - h; j >= 0; j = j - h)   //j = 3 j > 0 j--    j = 2 j >= 0 j--
			{
				if (tmp < a[j])
				{
					a[j + h] = a[j];
				}	
				else
				{
					break;
				}
			}
			a[j + h] = tmp;
		}
	}
}

int main()
{
	int i;
	//int array[] = {4, 2, 7, 9, 0, 6, 2, 1, 8, 3};
	int array[10000] = {0};
	srand(time(NULL));
	for (i = 0; i < 10000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	InsertSort(array, sizeof(array) / sizeof(array[0]));

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}

4简单排序

#include <stdio.h>

void SelectSort(int *a, int length)
{
	int i, j, min, index;

	for (i = 0; i < length - 1; i++)
	{
		min = a[i];	
		index = i;
		for (j = i + 1; j <= length - 1; j++)
		{
			if (a[j] < min)
			{
				min = a[j];
				index = j;
			}
		}
		if (index != i)
		{
			a[i] = a[i] + a[index];
			a[index] = a[i] - a[index];
			a[i] = a[i] - a[index];
		}
	}
}

int main()
{
	int i;
	//int array[] = {4, 2, 7, 9, 0, 6, 2, 1, 8, 3};
	int array[10000] = {0};
	srand(time(NULL));
	for (i = 0; i < 10000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	SelectSort(array, sizeof(array) / sizeof(array[0]));

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}

5堆排序

#include <stdio.h>

/*
函数描述：构建大顶堆
函数参数：数组  根节点的下标  最后一个结点的下标
*/
void AdjustMaxHeap(int *a, int root, int last)
{
	int i, child;
	int tmp = a[root];
	for (; 2 * root + 1 <= last; root = child)
	{
		child = 2 * root + 1;
		if (child + 1 <= last && a[child] < a[child + 1])
		{
			child++;
		}
		if (a[child] > a[root])
		{
			a[root] = a[child];
			a[child] = tmp;
		}
		else
		{
			break;
		}
	}
}

void swap(int *x, int *y)
{
	int t = *x;
	*x = *y;
	*y = t;
}

void HeapSort(int *a, int length)
{
	//构建大顶堆
	int i;
	for (i = length / 2 - 1; i >= 0; i--)
	{
		AdjustMaxHeap(a, i, length - 1);		
	}

	//调整大顶堆
	for (i = length - 1; i > 0; i--)
	{
		swap(&a[0], &a[i]);
		AdjustMaxHeap(a, 0, i - 1);
	}
}

int main()
{
	int i;
	//int array[] = {4, 2, 7, 9, 0, 6, 2, 1, 8, 3};
	int array[100000] = {0};
	srand(time(NULL));
	for (i = 0; i < 100000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	HeapSort(array, sizeof(array) / sizeof(array[0]));

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}

6冒泡排序

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

void get_array(int a[], int length)
{
	int i;
	//int size = sizeof(a) / sizeof(a[0]);   //在调用的函数里面不能求数组长度
	//printf("shuru 5 ge shu\n");
	srand(time(NULL));
	for(i = 0; i < length; i++)
	{
		a[i] = rand() % 1000;
	}
}

void sort(int a[], int length)
{
	int i, j;
	for(i = 0; i < length - 1; i++)
	{
		for (j = 0; j < length - i - 1; j++)
		{
			if (a[j] > a[j + 1])
			{
			#if 0
				int tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
			#endif
				a[j] = a[j] + a[j + 1];
				a[j + 1] = a[j] - a[j + 1];
				a[j] = a[j] - a[j + 1];
			}
		}
	}
	
}

void print_array(int a[], int length)
{
	int i;
	for (i = 0; i < length; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	
}

int main()
{
	int i, j, a[100000] = {0};

	get_array(a, sizeof(a) / sizeof(a[0]));

	sort(a, sizeof(a) / sizeof(a[0]));

	print_array(a, sizeof(a) / sizeof(a[0]));


	return 0;
}

7归并排序

#include <stdio.h>
#include <stdlib.h>

void Merge(int *a, int start, int mid, int end)
{
	int LeftLen = mid - start + 1;
	int RightLen = end - mid;
	int *L = (int *)malloc(sizeof(int) * LeftLen);
	int *R = (int *)malloc(sizeof(int) * RightLen);

	int i, k, j;
	for (i = 0, k = start; i < LeftLen; i++, k++)
	{
		L[i] = a[k];
	}
	for (j = 0; j < RightLen; j++, k++)
	{
		R[j] = a[k];
	}

	for (i = 0, j = 0, k = start; i < LeftLen && j < RightLen; k++)
	{
		if (L[i] < R[j])
		{
			a[k] = L[i++];
		}
		else
		{
			a[k] = R[j++];
		}
	}

	if (j < RightLen)
	{
		for (; j < RightLen; j++, k++)
		{
			a[k] = R[j];
		}
	}
	if (i < LeftLen)
	{
		for (; i < LeftLen; i++, k++)
		{
			a[k] = L[i];
		}
	}
}

void MergeSort(int *a, int start, int end)
{
	if (start >= end)
	{
		return;
	}

	int mid = (start + end) / 2;
	MergeSort(a, start, mid);            //拆分，拆成数组只有1个元素
	MergeSort(a, mid + 1, end);

	Merge(a, start, mid, end);
}

int main()
{
	int i;
	//int array[] = {4, 2, 7, 9, 0, 6, 2, 1, 8, 3};
	int array[10000] = {0};
	srand(time(NULL));
	for (i = 0; i < 10000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	MergeSort(array, 0, sizeof(array) / sizeof(array[0]) - 1);

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}

8基数排序

#include <stdio.h>
#include <stdlib.h>

void RadixSort(int *a, int length)
{
	int max = a[0], i, radix = 1;
	for (i = 1; i < length; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
	}

	int *t = (int *)malloc(sizeof(int) * length);
	while (max / radix != 0)
	{
		int bucket[10] = {0};                 //记录每个桶有多少个数字
		for (i = 0; i < length; i++)
		{
			bucket[a[i] / radix % 10]++;
		}
		
		for (i = 1; i <= 9; i++)
		{
			bucket[i] = bucket[i] + bucket[i - 1];
		}

		for (i = length - 1; i >= 0; i--)
		{
			t[bucket[a[i] / radix % 10] - 1] = a[i];
			bucket[a[i] / radix % 10]--;
		}

		for (i = 0; i < length; i++)
		{
			a[i] = t[i];
		}

		radix = radix * 10;
	}

	free(t);
}

int main()
{
	int i;
	//int array[] = {400, 2234, 789, 119, 11110, 666, 22, 11, 78, 3};
	int array[10000] = {0};
	srand(time(NULL));
	for (i = 0; i < 10000; i++)
	{
		array[i] = rand() % 1000 + 1;
	}

	RadixSort(array, sizeof(array) / sizeof(array[0]));

	for (i = 0; i < sizeof(array) / sizeof(array[0]); i++)
	{
		printf("%d ", array[i]);
	}
	printf("\n");

	return 0;
}
linux C 常用的排序，查找，算法的C语言实现 动态库
05-20
动态共享库中函数名： void Bubble_Sort(int a[],int len)；/*冒泡排序*/ void Select_Sort(int a[], int len)；/*选择排序*/ void Insertion_Sort(int a[], int len)；/*插入排序*/ int Binary_Search(int a[], int start,int end, int key)；/*折半查找*/ 用gcc与main函数 一起链接，即可调用库中函数！
[转贴]八大排序算法总结
weixin_30564785的博客
10-19 330
原文见：http://blog.csdn.net/yexinghai/archive/2009/10/10/4649923.aspx插入排序 1.直接插入排序 原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。 要点：设立哨兵，作为临时存储和判断数组边界之用。 实现： VoidInsertSort(...
快速排序的Linux下C语言实现
PixelLoom的博客
10-01 160
在本文中，我们将介绍如何在Linux下使用C语言实现快速排序算法，并提供相应的源代码。快速排序的原理是通过分治的思想，将一个数组分成两个子数组，然后分别对这两个子数组进行排序，最终将它们合并为一个有序数组。函数，该函数实现了快速排序的递归过程。在每一次递归中，我们选择第一个元素作为基准元素，并通过。函数，该函数实现了快速排序的递归过程。在每一次递归中，我们选择第一个元素作为基准元素，并通过。用于将数组划分为两部分，并返回基准元素的索引。用于将数组划分为两部分，并返回基准元素的索引。函数打印排序后的数组。
linux c 排序算法,C语言实现各类排序算法
weixin_28829339的博客
05-14 355
最近准备面试，重温数据结构，先给出各类排序算法，算法中注释比较少若想下载注释比较全的源代码上我的csdn下载我上学的时候写的：与现在写的有些区别。以下代码是这次写的，算法中对于指针与引用的选择。读者自己可以根据需要修改，冒泡算法是指针类型做函数变量，为了方便其余算法是C++引用。主函数中将注释更改后就可以实现各类排序算法。#include #include #include #define MAX...
C语言实现8种排序
热门推荐
小浩子的博客
02-24 3万+
最近要开始准备春招了，没什么时间学习spring，得忙着刷题。这两天复习排序，综合网上和书上的资料，整理了下面8种排序算法的实现。基于C语言的，java版本很快就出来。 具体代码：#include<stdio.h> #include<stdlib.h> //冒泡排序 void bubleSort(int data[], int n); //快速排序 void quickSort(int data[
Linux C语言 内置排序函数对结构体排序
weixin_44339041的博客
09-19 442
qsort()函数是 C 库中实现的快速排序算法。
十大排序算法——选择排序法
qq_45844792的博客
04-19 474
选择排序法 原理： 假设首个元素为最大值，用i,j,k三个变量表示数组下标，i表示当前元素下标，j表示找到最大值或者最小值的元素下标，k表示每次循环后的最大值或者最小值的下标 思路： 假设首个元素为最大值或者最小值与其后的其他数值进行比较，如果后面的值有比当前值大或者小，就进行交换数值，依次循环进行排序。 C语言代码 #include<stdio.h> #include<stdl...
shell排序法-改良的插入排序（C）
Wenbin_Yang
11-24 383
说明插入排序法由未排序的后半部前端取出一个值，插入已排序前半部的适当位置，概念简单但速度不快。排序要加快的基本原则之一，是让后一次的排序进行时，尽量利用前一次排序后的结果，以加快排序的速度，Shell排序法即是基于此一概念来改良插入排序法。解法Shell排序法最初是D.L Shell于1959所提出，假设要排序的元素有n个，则每次进行插入排序时并不是所有的元素同时进行时，而是取一段间隔。 Shel
linux用c语言实现冒泡排序,C语言冒泡排序法的实现（升序排序法）
weixin_33364925的博客
05-13 563
任务代码：数字的排序：#include #define SIZE 10int main(){int a[SIZE]={12 ,43,9,13,67,98,101,89,3,35};//十个数的无序数列int i,j,t;printf("此程序使用冒泡排序法排列无序数列！\n");//冒泡排序for(i=0;i<10-1;i++)//n个数的数列总共扫描n-1次{for(j=0;j<10...
Lv1 C语言 每日作业
weixin_66422840的博客
03-23 859
C语言每日作业
100个经典c算法 | 程序源码
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
08-04 2131
通过100个经典C算法题目的代码编写巩固C语言基础并提升对C语言的理解。
Linux下编写选择排序（C语言）
涂作权的博客
07-04 1526
1、创建源文件。 vi bubble.c 2、编写源代码
Linux洗C语言基础编程——折半查找法
goodman_lqifei的博客
10-03 584
今天我们写一个选择法排序与折半查找法相结合的程序。主要实现先排序在查找。前面我们已经详细的讲过了选择排序法，现在我们来说下折半查找法 折半查找法的主要思想是 number与mid的比较                                         mid = （butt+top）/2 如果number大于mid，则top = mid+1； 如果number小于mid，则b
C语言学习打卡第8天
BlitheY的博客
02-18 230
C语言函数练习
Linux环境中实现C语言“冒泡排序”
m0_64886406的博客
12-19 1198
Linux环境中实现C语言“冒泡排序”
linux c 实现八大排序算法总结（转）
iteye_4495的博客
12-26 211
linux c 实现八大排序算法总结（转） 插入排序 1.直接插入排序 原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。 要点：设立哨兵，作为临时存储和判断数组边界之用。 实现： [liul@test algorithms]$ more InsertSort.c  ...
Linux C学习笔记-排序算法3-选择排序
我在学C语言
11-17 1209
选择排序 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 算法步骤 1 依次遍历数列的无序部分（第一次认为整个数列都为无序） 2 找出最小（或最大）的一个元素 3 将找出来的最小元素与无序数列第一个元素交换，使得无序数列的第一个元素也变成有序数列 4 重复上述步骤，直到无序数列中剩下一个元素为止 C语言示例
hello.c编译成linux,编写Makefile文件,要求: 1)编译hello.c成为模块 2)使用linux的内核源码树目录...
weixin_42297982的博客
05-02 364
_为了避免嵌套的条件语句if-else的二义性,C语言规定( )(2.0分)71以下帝王陵寝封土为“宝城宝顶”的是()地形测绘是获取具有现势性的____。建筑各楼层地面标高应以相对标高标注,并应与建筑专业一致。( )设L是曲线 与直线 所围成区域的整个边界曲线, 是连续函数,则电解饱和食盐水阴极产生的气体可使湿润的淀粉 ­ KI 试纸变蓝。 (5.0分)一般...
C++软件工程师，你该会什么？
CodeDream
07-12 8679
请尊重原创: 转载注明来源   原创在这里哦 C语言广泛用于基础软件、桌面系统、网络通信、音频视频、游戏娱乐等诸多领域。是世界上使用最广泛的编程语言之一。随着物联网技术的发展，C/C++技术在3G网络通信（移动网络、互联网、Zigbee等专用网络）、多媒体处理、智能识别等领域得到了进一步的推动和发展。 作为资深的C++国际软件工程师，必须具备的技能有： 首先，C语言的开发基础（C
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值