C语言排序算法（十种排序代码可跑

最新推荐文章于 2023-06-14 10:16:52 发布
最新推荐文章于 2023-06-14 10:16:52 发布
阅读量2.5k 收藏 42
点赞数 7
分类专栏： 数据结构C语言代码 文章标签： 算法 c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangchengjiea/article/details/120186815
版权

C语言排序算法（十种排序代码可跑）

冒泡排序：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define N 10
 
void bubble_sort(int k[], int n)
{
	int i, j, temp;
	for (i = 0; i < n - 1; i++)      //外循环表示比较n-1轮
	{
		for (j = 0; j < n-1-i; j++)     //内循环表示每轮比较结束后，最后一个值最大，每轮除去最后一个继续比较
		{
			if (k[j] > k[j+1])
			{
				temp = k[j];
				k[j] = k[j+1];
				k[j+1] = temp;
			}
		}
	}
}
 
int main()
{
	int k[N];
	int i;
    srand((unsigned int)time(NULL));//获取随机数种子
	for(i=0;i<N;i++)
		k[i] = rand() % N;
	bubble_sort(k,N);
 
	for(i=0;i<N;i++)
		printf("%d ",k[i]);
 
	printf("\n");
    system("pause");   //可以实现冻结屏幕，便于观察程序的执行结果
	return 0;
}

选择排序：

#include<stdio.h>
#include<stdlib.h>
 
void select(int k[], int n)
{
	int i, j, temp, min;
	for (i = 0; i < n - 1; i++)      //外循环表示选择n-1轮
	{
		min = i;
		for (j = i + 1; j < n; j++)     //内循环挑选最小的值，下标赋值给min
		{
			if (k[j] < k[min])
				min = j;
		}
		if (min != i)
		{
			temp = k[i];
			k[i] = k[min];
			k[min] = temp;
		}
	}
	printf("\n");
}
 
int main()
{
	int i, k[10] = { 2, 5, 7, 9, 0, 1, 2, 4, 3, 6 };
	select(k, 10);
	for (i = 0; i < 10; i++)
		printf("%d ", k[i]);
	system("pause");   //可以实现冻结屏幕，便于观察程序的执行结果
	return 0;
}

插入排序：

#include "stdio.h"

void InsertSort(int a[], int n)  //直接插入排序
{
	int i,j,temp=0;
	for(i=1;i<n;i++)
	{
		if(a[i]<a[i-1])
		{
			temp = a[i];
			for(j=i-1;j>=0 && a[j]>temp;j--)
			{
				a[j+1]=a[j];
			}
			a[j+1]=temp; //
		}
	}
	
}

void main()
{
	int a[10]={0,6,67,34,56,45,12,4,7,49};
	int i=0;
	InsertSort(a,10);
	for(i=0;i<10;i++)
		printf("%d ",a[i]);
	
}

归并排序：

#include <stdio.h>
#include <stdlib.h>
#define N 7

void merge(int arr[], int low, int mid, int high){
    int i, k;
    int *tmp = (int *)malloc((high-low+1)*sizeof(int));
    //申请空间，使其大小为两个
    int left_low = low;
    int left_high = mid;
    int right_low = mid + 1;
    int right_high = high;

    for(k=0; left_low<=left_high && right_low<=right_high; k++){  // 比较两个指针所指向的元素
        if(arr[left_low]<=arr[right_low]){
            tmp[k] = arr[left_low++];
        }else{
            tmp[k] = arr[right_low++];
        }
    }

    if(left_low <= left_high){  //若第一个序列有剩余，直接复制出来粘到合并序列尾
    //memcpy(tmp+k, arr+left_low, (left_high-left_low+l)*sizeof(int));
    for(i=left_low;i<=left_high;i++)
        tmp[k++] = arr[i];
    }

    if(right_low <= right_high){
    //若第二个序列有剩余，直接复制出来粘到合并序列尾
    //memcpy(tmp+k, arr+right_low, (right_high-right_low+1)*sizeof(int));
        for(i=right_low; i<=right_high; i++)
            tmp[k++] = arr[i];
    }

    for(i=0; i<high-low+1; i++)
        arr[low+i] = tmp[i];
    free(tmp);
    return;
}

void merge_sort(int arr[], unsigned int first, unsigned int last){
    int mid = 0;
    if(first<last){
        mid = (first+last)/2; /* 注意防止溢出 */
        /*mid = first/2 + last/2;*/
        //mid = (first & last) + ((first ^ last) >> 1);
        merge_sort(arr, first, mid);
        merge_sort(arr, mid+1,last);
        merge(arr,first,mid,last);
    }
    return;
}

int main(){
    int i;
    int a[N]={32,12,56,78,76,45,36};

    printf ("排序前 \n");
    for(i=0;i<N;i++)
        printf("%d\t",a[i]);

    merge_sort(a,0,N-1);  // 排序

    printf ("\n 排序后 \n");
    for(i=0;i<N;i++)
        printf("%d\t",a[i]); printf("\n");

    system("pause");
    return 0;
}

快速排序：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
 
void PrintArray(int arr[], int len)
{
	int i;
	for (i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
 
void QuickSort(int arr[], int start, int end)
{
	int i = start, j = end;
	int temp = arr[start];  //基准数
	if (i < j)
	{
		while (i < j)
		{
			while (i<j && arr[j] >= temp)  //从右向左，找小于temp的
			{
				j--;
			}
			if (i < j)     //填坑
			{
				arr[i] = arr[j];
				i++;
			}
 
			while (i<j && arr[i] < temp)  //从左向右，找大于temp的
			{
				i++;
			}
			if (i < j)      //填坑
			{
				arr[j] = arr[i];
				j--;
			}
		}
		arr[i] = temp;                  //把基准数放到 i=j 位置
		QuickSort(arr, start, i - 1);   //左半部分快排 
		QuickSort(arr, i + 1, end);     //右半部分快排
	}
}
 
int main(){
	int arr[10] = { 8, 6, 5, 7, 9, 0, 1, 2, 4, 3 };
	int len = sizeof(arr) / sizeof(int);
 
	PrintArray(arr, len);
	QuickSort(arr, 0, len - 1);
	PrintArray(arr, len);
	system("pause");
	return 0;
 
}

希尔排序：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<time.h>
#define N 10
 
void PrintArray(int arr[], int len)
{
	int i;
	for ( i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
 
void ShellSort(int arr[], int len)
{
	int i, j, k, temp,increasement = len;
	do{
		increasement = increasement / 3 + 1;  //确定分的组数，最后组数为1
		for (i = 0; i < increasement; i++)     //遍历每组
		{
			for (j = i + increasement; j < len; j += increasement)  //每组分别进行插入排序
			{
				if (arr[j] < arr[j - increasement])
				{
					temp = arr[j];
					for (k = j - increasement; k >= 0 && arr[k] > temp; k -= increasement)
					{
						arr[k + increasement] = arr[k];
					}
					arr[k + increasement] = temp;
				}
			}
		}
	} while (increasement > 1);
}
 
int main()
{
	int arr[N];
	int i;
	srand((unsigned)time(NULL));
	for (i = 0; i < N; i++)
    {
		arr[i] = rand() % N;      //得到0--N-1的随机数
	}
	PrintArray(arr, N);
	ShellSort(arr, N);
	PrintArray(arr, N);
	system("pause");
	return 0;
}

堆排序：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
 
//打印函数
void PrintArray(int arr[], int len)
{
	int i;
	for (i = 0; i < len; i++)
		printf("%d ", arr[i]);
	printf("\n");
}
 
//交换数组中的两个元素
void swap(int arr[], int a, int b)
{
	int temp = arr[a];
	arr[a] = arr[b];
	arr[b] = temp;
}
 
void HeapAdjust(int arr[], int index, int len)
{
	//保存当前节点的下标
	int max = index;
 
	//保存左右孩子的下标
	int lchild = index * 2 + 1;
	int rchild = index * 2 + 2;
 
	if (lchild<len&&arr[lchild]>arr[max])
		max = lchild;
	if (rchild<len&&arr[rchild]>arr[max])
		max = rchild;
	if (max != index)
	{
		//交换两个结点
		swap(arr, max, index);
		HeapAdjust(arr, max, len);
	}
}
 
void HeapSort(int arr[], int len)
{
	int i;
	for (i = len / 2 - 1; i >=0 ; i--)
	{
		//初始化堆
		HeapAdjust(arr, i, len);  //刚开始从下往上调整
	}
 
	//交换顶堆元素和最后一个元素
	for (i = len - 1; i >=0 ; i--)
	{
		swap(arr, 0, i);
		HeapAdjust(arr, 0, i);   //从上往下调整
	}
}
 
int main(){
	int arr[10] = { 8, 6, 5, 7, 9, 0, 1, 2, 4, 3 };
	int len = sizeof(arr) / sizeof(int);
	PrintArray(arr, len);
 
	//堆排序
	HeapSort(arr,len);
	PrintArray(arr, len);
	system("pause");
	return 0;
}

计数排序：

#include <stdio.h>
#include <stdlib.h>
#define random(x) rand()%(x)
#define NUM 100     // 产生100个随机数
#define MAXNUM 200     //待排序的数字范围是0-200
void countingSort(int A[], int n, int k){
    int *c, *b;
    int i;
    c = (int *)malloc(sizeof(int)*k);/*临时数组,注意它的大小是待排序序列中值最大的那个。如假定该排序序列中最大值为1000000，则该数组需要1000000*sizeof(int)个存储单元*/
    b = (int *)malloc(sizeof(int)*n);  /*存放排序结果的数组*/
    for (i = 0; i < k; i++)
        c[i] = 0;                       /*初始化*/
    for (i = 0; i < n; i++)
        c[A[i]] += 1;                   /*统计数组A中每个值为i的元素出现的次数*/
    for (i = 1; i < k; i++)
       c[i] = c[i - 1] + c[i];         /*确定值为i的元素在数组c中出现的位置*/
    for (i = n - 1; i >= 0; i--)
    {
        b[c[A[i]] - 1] = A[i];       /*对A数组，从后向前确定每个元素所在的最终位置;*/
        c[A[i]] -= 1;
    }
    for (i = 0; i < n; i++)
        A[i] = b[i];                /*这个目的是返回A数组作为有序序列*/
    free(c);
    free(b);
}
void printArray(int A[], int n){
    int i = 0;
    for (i = 0; i < n; i++){
        printf("%4d", A[i]);
    }
    printf("\n");
}
/*测试*/
int main()
{
    int A[NUM];
    int i;
    for (i = 0; i < NUM; i++)
        A[i] = random(MAXNUM);
    printf("before sorting:\n");
    printArray(A, NUM);
    countingSort(A, NUM, MAXNUM);
    printf("after sorting:\n");
    printArray(A, NUM);
    return 0;
}

桶排序：

#include <stdio.h>
void main()
{
    int a[11],i,j,t;
    for(i=0;i<=10;i++)
	{
		a[i]=0;//初始化为0
	}
	for(i=0;i<5;i++)//循环读入5个数
	{
		scanf("%d",&t);//把每一个数读到变量t中
		a[t]++;//进行计数
	}
	for(i=0;i<=10;i++)//依次判断a[0]~a[10]
	{
		for(j=0;j<a[i];j++)//出现了几次就打印几次
		{
			printf("%d",i);
		}
	}
}

基数排序：

#include<stdio.h>

#define Max_ 10      //数组个数
#define RADIX_10 10    //整形排序
#define KEYNUM_31 10     //关键字个数，这里为整形位数

// 打印结果
void Show(int  arr[], int n)
{
    int i;
    for ( i=0; i<n; i++ )
        printf("%d  ", arr[i]);
    printf("\n");
}

// 找到num的从低到高的第pos位的数据
int GetNumInPos(int num,int pos)
{
	int temp = 1;
	int i;
	for (i = 0; i < pos - 1; i++)
		temp *= 10;
    
	return (num / temp) % 10;
}


//基数排序  pDataArray 无序数组；iDataNum为无序数据个数
void RadixSort(int* pDataArray, int iDataNum)
{	int i,pos,j,k;
int *radixArrays[RADIX_10];    //分别为0~9的序列空间
for (i = 0; i < 10; i++)
{
	radixArrays[i] = (int *)malloc(sizeof(int) * (iDataNum + 1));
	radixArrays[i][0] = 0;    //index为0处记录这组数据的个数
}

for (pos = 1; pos <= KEYNUM_31; pos++)    //从个位开始到31位
{
	for (i = 0; i < iDataNum; i++)    //分配过程
	{
		int num = GetNumInPos(pDataArray[i], pos);
		int index = ++radixArrays[num][0];
		radixArrays[num][index] = pDataArray[i];
	}
	
	for (i = 0, j =0; i < RADIX_10; i++)    //收集
	{
		
		for (k = 1; k <= radixArrays[i][0]; k++)
			pDataArray[j++] = radixArrays[i][k];
		radixArrays[i][0] = 0;    //复位
	}
}
}

int main()
{   //测试数据
    int arr_test[Max_] = { 8, 4, 2, 3, 5, 1, 6, 9, 0, 7 };
    //排序前数组序列
    Show( arr_test, Max_ );
    RadixSort( arr_test, Max_);
    //排序后数组序列
    Show( arr_test, Max_ );
    return 0;
}

以上就是所有代码，希望同学们好好学习！！！

石头ym
关注
  • 7
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
冒泡排序和快速排序
cjydsg123的博客
08-23 403
排序算法中重要的两种排序
排序算法C语言代码
dayslrk的博客
07-27 4160
常用算法排序C语言代码
C语言实现排序算法的六种方式
javascript_good的博客
06-14 9857
当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3];从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5];由于已经将a[0]中的数保存到X中，可以理解成在数组a[0]上挖了个坑，可以将其它数据填充到这来。此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。4．再重复执行2，3二步，直到i==j，将基准数填入a[i]中。
排序算法实战练习
uiop_uiop_uiop的博客
01-25 1180
排序总的来说可以分为两种： 内排序：排序过程全部在内存中进行。外排序：排序过程需要不断地进行内存和外存之间的数据交换。外部排序时，要将数据分批调入内存来排序，中间结果还要及时放入外存，显然外部排序要复杂得多。 下面主要实战练习内排序。 目录 直接插入排序 （二路）归并排序 希尔排序   快速排序 左右指针法 挖坑法 前后指针法 快速排序的优化 堆排序 冒泡排序 直...
C语言8大经典排序算法代码和详细注释
washCutBlow的博客
05-03 3207
冒泡排序 void bubbleSort(int *a, int an) { //从i开始排，总是在[i+1,nsize]去寻找比当前元素小的，并且交换，使得当前位置的值总是其后面最小的 for(int i=0;i<an;i++) for(int j=i+1;j<an;j++) if(a[i]>a[j]) swap(a,i,j);
C语言 奇偶排序算法详解及实例代码
01-21
C语言奇偶排序算法 奇偶排序，或奇偶换位排序，或砖排序，是一种相对简单的排序算法，最初发明用于有本地互连的并行计算。这是与冒泡排序特点类似的一种比较排序。该算法中，通过比较数组中相邻的（奇-偶）位置数字...
C语言排序算法冒泡排序
07-27
冒泡排序是一种简单且常见的排序算法，它重复地遍历待排序的元素，并依次比较相邻的两个元素，如果它们的顺序不正确则交换它们，直到整个序列排序完成。以下是对C语言冒泡排序的描述，不包含具体的代码实现： 基本...
C语言 选择排序算法详解及实现代码
12-31
选择排序是排序算法的一种，这里以从小到大排序为例进行讲解。 基本思想及举例说明 选择排序（从小到大）的基本思想是，首先，选出最小的数，放在第一个位置；然后，选出第二小的数，放在第二个位置；以此类推，...
C语言排序算法之冒泡排序
最新发布
12-25
冒泡排序是一种基础且经典的排序算法，主要应用于C语言编程中。它的工作原理是通过不断地交换相邻两个元素的位置，使得较大的元素逐渐“浮”到数组的一端，就像水中的气泡逐渐上升到水面一样，因此得名“冒泡排序”...
C语言快速排序算法例程代码
09-17
C语言快速排序算法例程代码，快速排序的基本思想是在待排序的序列中选择一个元素作为中间元素，将序列中小于等于中间元素的元素放到左边，大于中间元素的元素放到右边，然后递归地对左右两个子序列进行排序，直到...
常用排序算法C语言示例代码解说PDF
11-28
个人原创总结的常用排序算法C语言示例代码解说PDF，可以动态输出排序过程，以便理解排序算法的主旨思想。包含有直接插入排序,折半插入排序,2路直接插入排序,起泡排序,简单选择排序,快速排序,堆排序,（希尔排序，归并排序，基数排序为空白），供学习排序算法的爱好者参考。
C语言的5种简单排序算法
热门推荐
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
常见排序及代码实现
5683的博客
09-17 439
1 冒泡排序 1.1 排序说明 所谓冒泡，说的是每次都是相邻元素进行比较，从开始索引到结束索引，不断冒出的过程。 以升序为例： 第一轮 所有元素都参与，从索引0元素开始，和索引1元素相较，如果索引大的数值小，则互换位置，接着索引1元素继续以同样的方式和索引2元素相较……一直到最后一个元素。 第一轮下来，就能将所有元素中最大的元素冒泡到最后索引的位置。 第二轮 一样从索引0元素开始冒泡，不过第一轮已经确定最后一个为最大元素，所以这次只需要冒泡到倒数第二个元素。 第二轮也一样，可以将这次参与冒泡的元素中的最大
排序算法，思想+C语言代码
weixin_45788069的博客
06-30 709
本篇文章篇幅较长，我是为了考研写的，很多都是借鉴王道上的，初学者也可以看，都是排序基础算法； 每节内容有，排序思想、性能分析、代码实现、往年408出题等吧这里代码应该都是以增序（、从小到大）（、顺序）排序； 直接插入、冒泡和简单选择是最基本的，思想容易理解，代码实现也简单，适合元素个数n不是很大（n......
C语言 通用排序实现以及代码详解
weixin_59215611的博客
06-15 1141
编写一个排序函数，实现对任意类型的数据进行排序
c语言编程排课系统,C语言-课表排课系统.docx
weixin_39980575的博客
05-19 928
C语言-课表排课系统基本操作：输入并创建链表(单向和双向)〃参见:infcreato；装载〃算法与存储一致存储//图形模式下，进行文件读写操作后有无故的异常显示查询//算法参见pdemandO ;cdemand() ;wddemand();插入//算法参见 insert ();删除〃算法参见deleteO;排序//算法:选择排序。具体见psort () ;csort ();打印输出//算法参见:p...
C语言简单选择排序算法的实现
ZGUIZ的博客
01-25 6794
简单选择排序从元素中跳出最小关键字，将其放在已排序列的最后，未排序的序列最前，直到全部排序完成为止，其空间复杂度为O(1)，时间复杂度为O(n2)。下面是实现代码： 首先仍然是预定义和类型定义： #define OK 1 #define ERROR 0 typedef int Status; typedef int ElemType; typedef struct{ ElemType *
C语言各种排序方法总结。
weixin_39447690的博客
01-19 5569
今天接到中软国际的dsp开发的技术面试，问了我字符串排序如何进行排序，把有关排序的问题总结一下。 目前能够在网上搜寻到的排序有： 第一（NUM_ONE）： 冒泡排序(BubbleSort) 第二(NUM_TWO)： 快速排序(QuickSort) 第三(NUM_THREE)： 堆排序(HeapSort) 第四(NUM_FOUR)： 二路排序(HeapSort) 第五(NUM_FIVE)： ...
c语言排序代码实现
weixin_30299539的博客
09-14 497
关于快速，冒泡，选择，插入等排序，本人用代码实现，均能运行成功。 本文除了排序，针对几种swap函数，也进行了说明，通过汇编代码分析，swap1函数的效率最高。 #include<iostream>#include <cstdio> /*交换函数*/void swap1(int *a,int *b){ 　　int tmp = *a; 　　*a = *b; 　...
"C语言排序算法大全：快速排序及其他九种排序方法详解
快速排序是一种常用且高效的排序算法，通过不断地将数组分割成较小的子数组，并按照基准值进行排序，最终实现整个数组的排序。其基本思想是选择一个基准值，然后将数组分为两部分，小于基准值的放在左边，大于基准值...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值