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

作者：Gausst松鼠会 | 2024-03-21 03:41:40

踩

c语言排序代码

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

选择排序：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

插入排序：

#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]);
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

归并排序：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

快速排序：

#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;
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

希尔排序：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

堆排序：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

计数排序：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

桶排序：

#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);
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

基数排序：

#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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/278159