排序（三）：归并排序、基数排序

最新推荐文章于 2024-08-06 23:11:26 发布
最新推荐文章于 2024-08-06 23:11:26 发布
阅读量636 收藏 2
点赞数
分类专栏： 数据结构 c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39191122/article/details/81147518
版权

一、排序分析：
7、归并排序
时间复杂度：O(nlog2^n)
空间复杂度：O(n)
算法稳定性：稳定
这里写图片描述

//1、申请新数组，用来保存排序结果
//2、初始start/end1/start2/end2
//3、归并排序：
//  有两个归并段时，start1与start2元素进行比较
//      小于等于，保存start1值同时后移；
//      大于，保存start2值同时后移。
//  注：当任意一个归并段start移至end后时，即另一段剩余元素同时有序；
//      更新start/end1/start2/end2。
//  有一个归并段时，仅将其按顺序保存至brr
//4、更新arr
void Merge(int *arr, int len, int gap)//一次归并排序
{
    //申请新数组
    int *brr = (int *)malloc(sizeof(int) * len);
    assert(brr != NULL);
    //初始start/end1/start2/end2
    int i = 0;
    int start1 = 0;
    int end1 = start1 + gap - 1;
    int start2 = end1 + 1;
    int end2 = start2+gap-1 > len-1 ? len-1 : start2+gap-1;
    //开始归并排序
    while(start2 < len)//有两个归并段
    {
        while(start1 <= end1 && start2 <=end2)
        {
            if(arr[start1] <= arr[start2])//稳定性
            {
                brr[i++] = arr[start1++];
            }
            else
            {
                brr[i++] = arr[start2++];
            }
        }
        while(start1 <= end1)
        {
            brr[i++] = arr[start1++];
        }
        while(start2 <= end2)
        {
            brr[i++] = arr[start2++];
        }
        //更新start/end1/start2/end2
        start1 = end2 + 1;
        end1 = start1 + gap -1;
        start2 = end1 + 1;
        end2 = start2+gap-1 > len-1 ? len-1 : start2+gap-1;
    }
    while(start1 < len)//有一个归并段
    {
        brr[i++] = arr[start1++];
    }
    //更新arr
    for(i = 0; i < len; i++)
    {
        arr[i] = brr[i];
    }
    free(brr);
    brr = NULL;
}
//按 i*2 的步进方式，每次平分为 i*2 个元素的数据段，进行二路排序
void MergeSort(int *arr, int len)//归并排序
{
    for(int i = 1; i < len; i *= 2)
    {
        Merge(arr, len, i);
    }
}

8、基数排序
时间复杂度：O(d(r+n))
空间复杂度：O(rd+n)
算法稳定性：稳定
这里写图片描述

//1、初始十个桶（0-9）：单链表建立
//2、确定入桶（与出桶）次数：最大元素位数count
//3、完成每次的入桶与出桶：即figure位的排序
//  得到 figure位数字；
//  按照0-9号桶对应插入；
//  从0-9号桶依次出桶（当前桶全部出完才能开始出下一个桶）。
//4、当完成count次入桶、出桶操作后，即整体有序
void Base(int *arr, int len, int figure)//一次入桶、出桶
{
    //初始十个桶
    Node head[10];
    int i = 0;
    int tmp = 0;
    for(i = 0; i < 10; i++)
    {
        InitList(&head[i]);
    }
    //入桶
    for(i = 0; i < len; i++)
    {
        tmp = GetNum(arr[i], figure);
        Insert(&head[tmp], arr[i]);
    }
    //出桶
    i = 0;
    for(int j = 0; j <10; )
    {
        if(Delet(&head[j], &arr[i]))
        {
            i++;
        }
        else
        {
            j++;
        }
    }
}

void BaseSort(int *arr, int len)//基数排序
{
    int count = GetMaxBit(arr, len);

    for(int i = 0; i <count; i++)
    {
        Base(arr, len, i);
    }
}

二、代码实现

#include<stdio.h>
#include<assert.h>
#include<malloc.h>

//归并排序（二路归并）
//子序列有序->子序列间有序->整体有序


//1、申请新数组，用来保存排序结果
//2、初始start/end1/start2/end2
//3、归并排序：
//  有两个归并段时，start1与start2元素进行比较
//      小于等于，保存start1值同时后移；
//      大于，保存start2值同时后移。
//  注：当任意一个归并段start移至end后时，即另一段剩余元素同时有序；
//      更新start/end1/start2/end2。
//  有一个归并段时，仅将其按顺序保存至brr
//4、更新arr
void Merge(int *arr, int len, int gap)//一次归并排序
{
    //申请新数组
    int *brr = (int *)malloc(sizeof(int) * len);
    assert(brr != NULL);
    //初始start/end1/start2/end2
    int i = 0;
    int start1 = 0;
    int end1 = start1 + gap - 1;
    int start2 = end1 + 1;
    int end2 = start2+gap-1 > len-1 ? len-1 : start2+gap-1;
    //开始归并排序
    while(start2 < len)//有两个归并段
    {
        while(start1 <= end1 && start2 <=end2)
        {
            if(arr[start1] <= arr[start2])//稳定性
            {
                brr[i++] = arr[start1++];
            }
            else
            {
                brr[i++] = arr[start2++];
            }
        }
        while(start1 <= end1)
        {
            brr[i++] = arr[start1++];
        }
        while(start2 <= end2)
        {
            brr[i++] = arr[start2++];
        }
        //更新start/end1/start2/end2
        start1 = end2 + 1;
        end1 = start1 + gap -1;
        start2 = end1 + 1;
        end2 = start2+gap-1 > len-1 ? len-1 : start2+gap-1;
    }
    while(start1 < len)//有一个归并段
    {
        brr[i++] = arr[start1++];
    }
    //更新arr
    for(i = 0; i < len; i++)
    {
        arr[i] = brr[i];
    }
    free(brr);
    brr = NULL;
}


//按 i*2 的步进方式，每次平分为 i*2 个元素的数据段，进行二路排序
void MergeSort(int *arr, int len)//归并排序
{
    for(int i = 1; i < len; i *= 2)
    {
        Merge(arr, len, i);
    }
}

void Show(int *arr, int len)
{
    assert(arr != NULL);
    for(int i = 0; i < len; i++)
    {
        printf("%d  ", arr[i]);
    }
    printf("\n");
}

int main()
{
    int arr[] = {7,5,0,4,3,1,2};
    int len = sizeof(arr) / sizeof(arr[0]);
    MergeSort(arr, len);
    Show(arr, len);
    getchar();
    return 0;
}
#include<stdio.h>
#include<assert.h>
#include<malloc.h>

//基数排序（桶子法）


//建立单链表
typedef struct Node
{
    int data;
    struct Node *next;
}Node, *List;

void InitList(List plist)
{
    assert(plist != NULL);
    plist->next = NULL;
}

static Node *GetNode(int val)
{
    Node *pGet = (Node *)malloc(sizeof(Node));
    assert(pGet != NULL);

    pGet->data = val;
    pGet->next = NULL;

    return pGet;
}

bool Insert(List plist, int val)//尾插
{
    assert(plist != NULL);
    Node *pGet = GetNode(val);

    Node *p = plist;
    while(p->next != NULL)
    {
        p = p->next;
    }
    p->next = pGet;

    return true;
}

bool Delet(List plist, int *rtv)//头删
{
    assert(plist != NULL);

    if(plist->next == NULL)
    {
        return false;
    }

    Node *pDel = plist->next;
    if(rtv != NULL)
    {
        *rtv = pDel->data;
    }
    plist->next = pDel->next;
    free(pDel);
    pDel = NULL;

    return true;
}

//相关函数实现
int GetMaxBit(int *arr, int len)//入桶次数：最大元素位数
{
    //得到最大元素
    int max = arr[0];
    for(int i = 1; i <len; i++)
    {
        if(max < arr[i])
        {
            max = arr[i];
        }
    }
    //得到元素位数
    int count = 0;
    while(max != 0)
    {
        count++;
        max /= 10;
    }

    return count;
}

int GetNum(int num, int figure)//应入桶号：figure位数字
{
    for(int i = 0;i < figure;i++)
    {
        num/=10;
    }

    return num%10;
}

//低位有序->高位有序->整体有序
//1、初始十个桶（0-9）：单链表建立
//2、确定入桶（与出桶）次数：最大元素位数count
//3、完成每次的入桶与出桶：即figure位的排序
//  得到 figure位数字；
//  按照0-9号桶对应插入；
//  从0-9号桶依次出桶（当前桶全部出完才能开始出下一个桶）。
//4、当完成count次入桶、出桶操作后，即整体有序
void Base(int *arr, int len, int figure)//一次入桶、出桶
{
    //初始十个桶
    Node head[10];
    int i = 0;
    int tmp = 0;
    for(i = 0; i < 10; i++)
    {
        InitList(&head[i]);
    }

    //入桶
    for(i = 0; i < len; i++)
    {
        tmp = GetNum(arr[i], figure);
        Insert(&head[tmp], arr[i]);
    }

    //出桶
    i = 0;
    for(int j = 0; j <10; )
    {
        if(Delet(&head[j], &arr[i]))
        {
            i++;
        }
        else
        {
            j++;
        }
    }
}

void BaseSort(int *arr, int len)//基数排序
{
    int count = GetMaxBit(arr, len);

    for(int i = 0; i <count; i++)
    {
        Base(arr, len, i);
    }
}

void Show(int *arr, int len)
{
    assert(arr != NULL);

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

int main()
{
    int arr[] = {12,3,1,8,34,21,88,54,0};
    int len = sizeof(arr)/sizeof(arr[0]);
    BaseSort(arr,len);
    Show(arr,len);
    getchar();
    return 0;
}

三、八大排序总结
1、分类：
1)、插入排序：
直接插入排序———->优化：shell排序

2)、选择排序：
直接选择排序———->优化：堆排序

3)、交换排序：
冒泡排序———->优化：快速排序

4)、归并排序

5）、基数排序
这里写图片描述

2、应用场景：
整体元素个数为n，
1）n较小，直接选择排序（不考虑稳定性）/直接插入排序

2）n较小，且整体或局部有序时，直接插入排序/冒泡排序/快速排序（随机）

3）n较大，快速排序（平均时间最短）/堆排序（内存空间允许且要求稳定性）/归并排序（内存空间允许且要求稳定性）

4）数据无符号，且可分解，基数排序

5）待排序元素间隔距离跨度较大，shell排序

Ahahahahaha_
关注
专栏目录
排序算法_排序算法_
10-03
本篇文章将详细探讨基数排序、归并排序、堆排序、快速排序以及希尔排序这五种常见的排序算法，理解它们的基本思想以及实现方式。 1. **基数排序**： - **基本思想**：基数排序是一种非比较型整数排序算法，其原理...
归并排序和基数排序
aaronkwo的博客
05-03 562
一、归并排序 1、基本思路 归并的含义是将两个或者两个以上的有序表组合成一个新的有序表。有2路归并和多路归并多种算法。下面以2路归并为例分析：假设一个序列有n个记录，则可以看做是有n个有序的子表，然后这n个字表两两归并，得到n/2或者（n/2）+1个有序子表，在两两归并.......直到只有一个子表，且表长为n时候结束。 2、示例代码 #include #include using nam
各类排序算法比较分析
abcnull 的博客
03-26 741
文章目录各排序算法表格比较各类排序算法场景分析一些解释 各排序算法表格比较 基本上排序算法，基于选择的排序除了希尔，快排，归并，堆排序之外没啥实用性，只不过是练手的工具罢了，像 O(n^2) 这样过高的时间复杂度，已经失去了它的实用意义了 排序类别 排序算法 平均时间复杂度 最好情况 时间复杂度 最坏情况 时间复杂度 空间复杂度 稳定性 适用场景 交换排序 冒泡排序 O(n^2) ...
九大排序算法之归并排序和基数排序【数据结构】22-12-3
weixin_53438051的博客
12-04 524
对{05,46,13,55,94,17,42}，进行基数排序，一趟排序的结果是
关于『基本算法』:常见八大排序
自强不息，厚德载物
01-30 2171
关于『基本算法』:常见八大排序
排序算法(四) -- 归并排序、基数排序
JeremyIverson的博客
02-21 491
1.归并排序 1.1 归并排序介绍: 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer） 策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 1.2 归并排序思想示意图 1-基本思想: 1.3 归并排序思想示意图 2-合并相邻有...
经典算法:基数排序的小例子
10-27
基数排序是一种非比较型整数排序算法，它利用...对于这样的情况，其他比较型排序算法，如快速排序、归并排序等可能会更合适。总的来说，基数排序是一种非常实用的排序算法，尤其在处理整数数据时能展现出优秀的性能。
C语言排序全集：归并排序；基数排序；快速排序；冒泡排序；选择排序；折半排序；希尔排序
07-31
C语言所有排序大全，解决了您日常上课考试学习的需要，在这里每一个程序都没有错误，其中压缩包包括了归并排序；基数排序；快速排序；冒泡排序；选择排序；折半排序；希尔排序这些日常排序，因为是全集所以大家踊跃...
冒泡排序；直接插入排序；希尔排序；快速排序；堆排序；归并排序；基数排序
05-16
这里我们将深入探讨七种经典的排序算法：冒泡排序、直接插入排序、希尔排序、快速排序、堆排序、归并排序以及基数排序。 1. **冒泡排序**： 冒泡排序是最基础的排序算法之一。它通过重复遍历待排序的数据序列，...
C++ 基数排序的实现实例代码
01-20
C++ 基数排序 　大家好,今天带来的是自己...高级一些的有快速排序,希尔排序,堆排序,归并排序,基数排序等. 其中时间复杂度为O(n*logn)的算法有快速排序,归并排序和堆排序等,其中快速排序的使用最为广泛.时间复杂度为O
排序算法之归并和基数
123木头人！
07-24 421
排序算法根据是否需要访问外存，分为内部排序和外部排序。 内部排序是指待排序列完全存放在内存中所进行的排序过程，适合不太大的元素序列。 外部排序是指大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，来达到排序整个文件的目的。 一.内部排序 使用内存，分为插入（直接插入排序希尔排序）、选择（简单选择排序堆排序）、交换（冒泡...
数据结构与算法-归并排序与基数排序
玄霄
06-03 450
归并排序与基数排序归并排序基本思想示意图归并排序思想示意图 2应用实例基数排序基数排序基本思想基数排序图文说明代码实现基数排序的说明 每个人的实现都有不同，重要是掌握其思想。 归并排序 归并排序（MERGE-SORT）是利用归并思想实现的排序方法，该算法采用经典的分治（divide-and-conquer） 策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修 补"在一起，即分而治之)。 基本思想示意图 归并排序思想示意图 2 合并相邻有
常用排序算法性能全面对比
GWB_superman的专栏
07-13 1756
介绍 插入排序 直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的有序的表中，从而得到一个新的、记录数增1的有序表。 　　当前元素的前面元素均为有序，要插入时，从当前元素的左边开始往前找（从后往前找），比当前元素大的元素均往右移一个位置，最后把当前元素放在它应该呆的位置就行了。 时间复杂度O(N^2) 二分插入排序 插入排序方式首先需要为要插入的元素找到插入序列中合适的插入位置。通过折半（（low+high）/2=mid）的方式，凭...
基数排序适用情况
mariodf的博客
06-02 979
基数排序适合于一下场景： 数据元素的关键字可以方便地拆分为 d 组，且 d 较小 每组关键字的取值范围不大，即 r 较小 数据元素个数 n 较大
【数据结构】 归并排序、 基数排序
四季轮换叶，一路招摇胜
10-10 1274
归并排序：将两个或两个以上的有序表合并成一个新的有序表。 基数排序：是一种借助于多关键字进行排序，也就是一种将单关键字按基数分成“多关键字”进行排序的方法。
深度解析基数排序：原理、实现与应用场景
i289292951的博客
04-13 1174
总结来说，基数排序是一种利用元素位值进行排序的非比较型算法，其线性时间复杂度、稳定性以及对特定数据类型的高效处理能力，使其在特定场景下展现出显著优势。形象地说，基数排序就像是图书馆管理员按照图书编号的不同位数进行分类、排序的过程：先按编号的个位数分堆，再按十位数分堆，以此类推，最后将所有堆按照编号顺序合并，得到整齐排列的图书序列。对于处理大规模数据集，特别是内存受限但硬盘空间充足的环境，基数排序由于其线性时间复杂度和较低的空间复杂度，能够有效应对大数据排序需求。每趟排序后，待排序序列都会变得更有序。
快速排序，希尔排序，归并排序，基数排序的时间复杂度比较
damoyuanzhuvhi的博客
08-08 475
希尔排序通过gap步长，不着眼于一个个细节，而着眼于全局，将全局向有序推进，从而相对于插值排序减少了移位次数，优化了时间，时间复杂度与gap有关，插值排序相当于gap=1的情况。快速排序最好的情况是选择的基数更将数组左右平分，这种情况下形成的递归树的高度为logn，每一层的规模为n，所以时间复杂度为O（nlogn）。基数排序处理一次的时间复杂度为O（n），处理的次数由最大数的位数决定，所以时间复杂度为O（n）。最坏的情况为基数总是最大或者最小，这种情况相当于冒泡排序，时间复杂度为O（n^2）
【数据结构】排序 —— 归并排序（mergeSort）、计数排序、基数排序
最新发布
明志の博客
08-06 964
海量数据的排序问题外部排序：排序过程需要在磁盘等外部存储进行的排序 前提：内存只有 1G，需要排序的数据有 100G因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序先把文件切分成 200 份，每个 512 M分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了。
归并排序与基数排序：比较与分析
本文档探讨了归并排序和基数排序两种不同的排序算法，并通过一个C++示例程序进行对比分析。首先，让我们了解一下这两个算法。 **归并排序**（Merge Sort）是一种基于分治策略的排序算法。它将数组分成两个相等或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值