算法--排序（C语言实现）

已于 2022-12-20 23:06:12 修改
阅读量163 收藏 1
点赞数 2
分类专栏： 算法 文章标签： 算法 c语言 排序算法
于 2022-11-19 17:05:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bingbingyihao/article/details/127925976
版权

算法--排序（C语言实现）

各排序算法的比较

下面以图示作为说明
在这里插入图片描述

排序说明

默认排序均排序成升序序列，使用 int 类型数组

插入式排序

插入排序

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void insertSort(Type arr[], int length)
{
    int i, j, index;
    Type temp;
    for (i = 0; i < length; i++)
    {
        temp = arr[i];
        index = i;
        for (j = i - 1; j >= 0; j--)
        {
            if (temp < arr[j])
            {
                index = j;
            }
            else
            {
                break;
            }
        }
        if (index != i)
        {

            for (j = i - 1; j >= index; j--)
            {
                arr[j + 1] = arr[j];
            }
            arr[index] = temp;
        }

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);
    insertSort(arr, length);
}

二分插入排序

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void halfInsertSort(Type arr[], int length)
{
    int i, j;
    int left, right, mid;
    Type temp;
    for (i = 0; i < length; i++)
    {
        temp = arr[i];
        left = 0;
        right = i - 1;

        while (left <= right)
        {
            mid = (left + right) / 2;
            if (arr[mid] < temp)
            {
                left = mid + 1;
            }
            else
            {
                right = mid - 1;
            }
        }
        mid = right + 1;

        for (j = i - 1; j >= mid; j--)
        {
            arr[j + 1] = arr[j];
        }
        arr[mid] = temp;

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

	halfInsertSort(arr, length);
}

希尔排序

采用 2 ^ k-1 作为间隔

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void shellInsert(Type arr[], int length, int step)
{
    int i, j, index;
    Type temp;
    for (i = 0; i < length; i++)
    {
        temp = arr[i];
        index = i;
        for (j = i - 1; j >= 0; j -= step)
        {
            if (temp < arr[j])
            {
                index = j;
            }
            else
            {
                break;
            }
        }
        if (index != i)
        {

            for (j = i - 1; j >= index; j -= step)
            {
                arr[j + step] = arr[j];
            }
            arr[index] = temp;
        }
    }
}

void shellSort(Type arr[], int step[], int arrLength, int stepLength)
{
    int i;
    for (i = 0; i < stepLength; i++)
    {
        shellInsert(arr, arrLength, step[i]);
    }

    printArr(arr, arrLength);
}

int getSize(int length)
{
    int start = 2;
    int count = 0;
    while (start < length)
    {
        start *= 2;
        count++;
    }
    return count;
}

void generateStep(int step[], int stepLength)
{
	int start = 1;
    int i;
    for (i = 0; i < stepLength; i++)
    {
		start *= 2;
		step[i] = start - 1;
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);
	
    int stepLength = getSize(length);
    int step[stepLength];
    generateStep(step, stepLength);
    shellSort(arr, step, length, stepLength);
}

交换式排序

冒泡排序

经典版本

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void bubbleSort(Type arr[], int length)
{
    int i, j;
    Type temp;
    for (i = 0; i < length; i++)
    {
        for (j = 0; j < length - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    bubbleSort(arr, length);
}

冒泡排序可以稍微改进一下，增加一个 flag 标志，标识在某一趟就已经排好序了，后面就不用再排序

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void bubbleSort(Type arr[], int length)
{
    int i, j;
    int flag = 1;
    Type temp;
    for (i = 0; i < length; i++)
    {
        flag = 0;
        for (j = 0; j < length - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                flag = 1;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }

        printArr(arr, length);
        if (flag == 0)
        {
            break;
        }
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    bubbleSort(arr, length);
}

快速排序

哨兵模式的经典版本，采用递归实现

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

int Partition(Type arr[], int low, int high)
{
    Type temp = arr[low];
    Type pivot = arr[low];
    while (low < high)
    {
        while (low < high && arr[high] >= pivot)
        {
            high--;
        }
        arr[low] = arr[high];
        while (low < high && arr[low] <= pivot)
        {
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = temp;
    return low;
}

void quickSort(Type arr[], int low, int high, int length)
{
    if (low < high)
    {
        int pivot = Partition(arr, low, high);
        quickSort(arr, low, pivot - 1, length);
        quickSort(arr, pivot + 1, high, length);
    }
    printArr(arr, length);
}

int main()
{
    Type arr[] = { 5, 3, 1, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    quickSort(arr, 0, length - 1, length);
}

采用辅助数组实现（相对哨兵模式会复杂一些，但并不难理解）

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

int Partition(Type arr[], Type temp[], int low, int high)
{
    Type pivot = arr[low];
    int index = low + 1;

    while (low < high)
    {
        if (arr[index] > pivot)
        {
            temp[high--] = arr[index++];
        }
        else
        {
            temp[low++] = arr[index++];
        }
    }
    temp[low] = pivot;

    printArr(temp, 10);
    return low;
}

void quickSort(Type arr[], Type temp[], int low, int high, int length)
{
    if (low < high)
    {
        int pivot = Partition(arr, temp, low, high);

        int i;
        for (i = low; i < pivot; i++)
        {
            arr[i] = temp[i];
        }
        quickSort(arr, temp, low, pivot - 1, length);

        for (i = pivot + 1; i <= high; i++)
        {
            arr[i] = temp[i];
        }
        quickSort(arr, temp, pivot + 1, high, length);
    }
}

int main()
{
    Type arr[] = { 5, 3, 1, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    Type temp[length] = { };
    quickSort(arr, temp, 0, length - 1, length);
}

选择式排序

选择排序

简单的选取然后交换

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void selectSort(Type arr[], int length)
{
    int i, j;
    int index;
    Type temp;
    for (i = 0; i < length; i++)
    {
        index = i;
        for (j = i + 1; j < length; j++)
        {
            if (arr[j] < arr[index])
            {
                index = j;
            }
        }
        if (index != i)
        {
            temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    selectSort(arr, length);
}

堆排序

堆排序是利用大根堆或者小根堆实现的排序，在这个排序里面要解决两个问题，如何建立一个堆，以及如何对堆进行调整

需要注意的是，堆排序比较在意下标的变化，在 建堆 和 堆调整时，如果下标都采用 i < high 则没问题，但如果是采用 i <= high ，则会在建堆的时候出现小问题，而且只对小根堆出现问题，大根堆不会出现问题

下面是采用 大根堆 进行的升序排序

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void heapAdjust(Type arr[], int low, int high)
{
    Type temp = arr[low];
    int i;
    for (i = 2 * low; i < high; i *= 2)
    {
        if (i < high && arr[i] < arr[i + 1])
        {
            i++;
        }
        if (temp >= arr[i])
        {
            break;
        }
        arr[low] = arr[i];
        low = i;
    }
    arr[low] = temp;
}

void createHeap(Type arr[], int length)
{
    int i;
    for (i = length / 2; i >= 0; i--)
    {
        heapAdjust(arr, i, length);
    }
}

void heapSort(Type arr[], int length)
{
    createHeap(arr, length);

    int i;
    Type temp;
    for (i = length - 1; i > 0; i--)
    {
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapAdjust(arr, 0, i - 1);

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 1, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    heapSort(arr, length);
}

下面是采用小根堆建立的降序排序

#include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void heapAdjust(Type arr[], int low, int high)
{
    Type temp = arr[low];
    int i;
    for (i = 2 * low; i < high; i *= 2)
    {
        if (i < high && arr[i] > arr[i + 1])
        {
            i++;
        }
        if (temp <= arr[i])
        {
            break;
        }
        arr[low] = arr[i];
        low = i;
    }
    arr[low] = temp;
}

void createHeap(Type arr[], int length)
{
    int i;
    for (i = length / 2; i >= 0; i--)
    {
        heapAdjust(arr, i, length);
    }
}

void heapSort(Type arr[], int length)
{
    createHeap(arr, length);

    int i;
    Type temp;
    for (i = length - 1; i > 0; i--)
    {
        temp = arr[0];
        arr[0] = arr[i];
        arr[i] = temp;
        heapAdjust(arr, 0, i - 1);

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 1, 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
    int length = sizeof(arr) / sizeof(Type);

    heapSort(arr, length);
}

归并排序

这里采用经典的递归实现，左划分，右划分，然后合并

# include <stdio.h>

#define MAX_SIZE 20
typedef int Type;

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

void merge(Type arr[], Type temp[], int start, int mid, int end)
{
	int k = 0;
	int i = start;
	int j = mid + 1;

	while (i <= mid && j <= end)
	{
		if (arr[i] <= arr[j])
		{
			temp[k++] = arr[i++];
		}
		else
		{
			temp[k++] = arr[j++];
		}
	}

	if (i == mid + 1)
	{
		while (j <= end)
		{
			temp[k++] = arr[j++];
		}
	}
	if (j == end + 1)
	{
		while (i <= mid)
		{
			temp[k++] = arr[i++];
		}
	}

	for (i = 0, j = start; i < k; i++, j++)
	{
		arr[j] = temp[i];
	}
	
	printArr(arr, end + 1);
}

void mergeSort(Type arr[], Type temp[], int start, int end)
{
	if (start >= end)
	{
		return;
	}
	int mid = (start + end) / 2;
	mergeSort(arr, temp, start, mid);
	mergeSort(arr, temp, mid + 1, end);
	merge(arr, temp, start, mid, end);
}

int main()
{
	Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 1, 1 };
	int length = sizeof(arr) / sizeof(Type);

	Type temp[length] = { };
	mergeSort(arr, temp, 0, length - 1);
	
	printArr(arr, length);
}

基数排序

不同于前面的比较式排序，这里采用桶思想，每次放入对应桶，从低位到高位，放入取出结束后，序列就有序了

#include <stdio.h>
#include <string.h>

#define MAX_SIZE 20
typedef int Type;

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

int getmaxLength(Type arr[], int length)
{
    int i;
    int max = 0;
    int count;
    Type temp;
    for (i = 0; i < length; i++)
    {
        count = 0;
        temp = arr[i];
        while (temp >= 1)
        {
            temp /= 10;
            count++;
        }
        if (count > max)
        {
            max = count;
        }
    }
    return max;
}

int getDigit(Type num, int i)
{
    while (i > 1)
    {
        num /= 10;
        i--;
    }
    return num % 10;
}

void radixSort(Type arr[], int length, int maxLength)
{
    int i, j, k, l, digit;
    Type temp[10][length] ;
    memset(temp, 0, sizeof(temp));

    for (i = 1; i <= maxLength; i++)
    {
        for (j = 0; j < length; j++)
        {
            digit = getDigit(arr[j], i);
            k = 0;
            while (temp[digit][k])
            {
                k++;
            }
            temp[digit][k] = arr[j];
        }
        l = 0;
        for (j = 0; j < 10; j++)
        {
            k = 0;
            while (temp[j][k])
            {
                arr[l++] = temp[j][k++];
            }
        }
        memset(temp, 0, sizeof(temp));

        printArr(arr, length);
    }
}

int main()
{
    Type arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10, 101, 1001 };
    int length = sizeof(arr) / sizeof(Type);

    int maxLength = getmaxLength(arr, length);
    radixSort(arr, length, maxLength);
}

附注

以上实现为经典规范方式，较容易理解与实现；对于快速排序、归并排序也是可以通过迭代而不是递归实现。
以及这里采用的是数组即线性表的方式，而不是链表，如果是链表，对于归并排序的复杂度可以降低

bingbingyihao
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言算法-实现冒泡排序
11-07
C语言算法——实现冒泡排序
C语言排序算法---冒泡排序法
03-23
在STM8S003单片机上实现数组排序，用3种冒泡排序法对数组进行排序，并通过串口打印排序过程。
排序算法-基于C语言实现的排序算法之RadixSort实现.zip
03-27
排序算法 排序算法_基于C语言实现的排序算法之RadixSort实现
排序算法-基于C语言实现的排序算法之QuickSort实现.zip
03-27
排序算法 排序算法_基于C语言实现的排序算法之QuickSort实现
排序算法-基于C语言实现的排序算法之PancakeSort实现.zip
03-27
排序算法 排序算法_基于C语言实现的排序算法之PancakeSort实现
C语言| 数组的折半查找
qq_40555264的博客
06-22 1254
3 此时a[2]=87,而key > a[2]=87,说明256在87的右边，则往右边查找。high = mid-1 = 2, 更新mid =(low+high)/2=1。low = mid+1, 更新mid=(low+high)/2，high不变。high = mid-1,更新mid=(low+high)/2,low不变。low = mid+1 =2, 更新mid =(low+high)/2=2。low = mid+1=4, 更新mid=(low+high)/2=5;
P1656 炸铁路
STY_fish_2012的博客
06-19 490
如果y的追溯值大于了x的时间戳，也就是y的追溯值在x之后，并且，y追溯到的这个点与x一定不连通，因为如果连通，那么y就会顺着这个点追溯到时间戳更小的点x，到这里，我们不难推出：x与y之间直接连通的边，只有这一条，并且没有间接联通的边。炸毁一条路对于一张图来说，本质上就是去掉一条边，不能通过铁路到达就代表这张图不连通了，对于这种去掉之后就可以使整张图不再连通的边，我们称之为割边。第一行 n,m (1≤n≤150，1≤m≤5000)，分别表示有 n 个城市，总共 m 条铁路。里面里面讲过，这里就不多说了。
LCR 076. 数组中的第 K 个最大元素
LuckyStar的博客
06-25 161
请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
LeetCode 100342. 最小元素和最大元素的最小平均值
m0_64381458的博客
06-23 259
更多题解尽在每日更新。组队打卡，更多解法等你一起来参与哦！，难度。
LeetCode 算法：排序链表 c++
小金牛来了
06-22 900
LeetCode 算法：排序链表 c++
Python低溫半导体电子束量子波算法计算
跨学科知识视角展现
06-23 918
:dart:任意维度求解器，绘制三维投影结果 | :dart:解二维静电场、静磁场 | :dart:狄利克雷、诺依曼条件几何矩阵算子 | :dart:算法模拟低溫半导体材料 | :dart:计算曲面达西流 | :dart:电子结构计算和原子模拟 | :dart:算法模拟量子波函数和电子束
LeetCode 算法：二叉树的最大深度 c++
小金牛来了
06-23 314
LeetCode 算法：二叉树的最大深度 c++
CF33b-B. String Problem
Hanknet的博客
06-18 320
给定两个字符串，给出n个op。对于每个op可以将一种字母转变为另一个字母，代价为d。需要求出通过上面的变化，让两个字符串相等的最小代价的字符串。c0，那么总成本为dp[c1][c0] + dp[c2][c0];也就是c1变成c0的最小成本加上。接下来我们考虑某一个位置，假设初始字符分别是c1,c2，最后变成了。先用Floyd计算出一个字母变换为另一个字母的最小代价，c2变成c0的最小成本。
算法07 深度优先搜索及相关问题详解
最新发布
bigbigli的博客
06-25 810
我们走迷宫的过程就是一个深度优先搜索的过程：从可以解决问题的某一个方向出发，并一直深入寻找，找到这个方向可以得到的所有解决方案，如果找不到，则回退到上一步，从另一个方向开始，再次深入寻找。解决问题时的注意事项1.首先弄清楚问题的解空间，即迷宫有多大。2.弄清楚搜索的边界，即到哪一步就该停下，不用再搜。3.搜索的方向，即可能包含哪几种子问题。void dfs()//参数用来表示状态if(到达终点状态){...//根据题意添加return;if(越界或者是不合法状态)return;
LeetCode 算法：随机链表的复制 c++
小金牛来了
06-22 585
LeetCode 算法：随机链表的复制 c++
谈谈跳台阶算法的记忆法和编程理念|青蛙跳台阶|递归|动态规划|算法|程序员面试|Java
GDUT_xin的博客
06-20 342
为什么会写这篇文章？因为鄙人刷过此题多次，每次觉得自己会了，可下次还是不能一下子写出题解，故记录下我是如何记忆此题的，并且探索一些编程理念。
【代码随想录】【算法训练营】【第43天】 [518]零钱兑换II [377]组合总和IV [卡码57]爬楼梯
weixin_54954007的博客
06-19 775
思路及算法思维，指路。题目来自。部分题目来自。day 43，极其困难的周三~
【回溯算法题记录】组合总和题汇总
weixin_43627638的博客
06-18 451
整体的逻辑就是我上面这张图这样（第二行的{2, 3} sum=5后面应该还有哈，但是我懒得画了）。如果至少一个数字的被选数量不同，则两种组合是不同的。所以除了第一次选择的元素之外，我们之后所做的操作都是相同的，那么就可以定义一个。的 所有 不同组合 ，并以列表形式返回。因为这题可以重复选取，那么我们每次选取都是在一个相同的集合中（例如。来表示我们首次选择的元素的index，用一个一维数组。放在类成员变量中，就不用写在函数入口。对于给定的输入，保证和为。但是不出意料的没通过。是当前路径统计的和。
代码随想录算法训练营第四十一天|01背包问题 二维 01背包问题 一维 416. 分割等和子集
滋滋牛排味的博客
06-25 286
踩坑：在考虑当前物品时，应先考虑当前的背包能不能放得下当前物品int。
程序员面试题--堆排序的C语言实现
05-27
好的，下面是堆排序的C语言实现代码： ```c #include void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } void heapify(int arr[], int n, int i) { int largest = i; // 初始化最大值为根...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值