单链表归并排序

最新推荐文章于 2026-05-27 14:21:16 发布
原创 最新推荐文章于 2026-05-27 14:21:16 发布 · 4.9k 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
C语言

当前文章被收录于：

C语言
16 篇文章 0 人学习
订阅专栏 查看详情
数据结构与算法

当前文章被收录于：

数据结构与算法
16 篇文章 0 人学习
订阅专栏 查看详情
本文介绍了针对单链表的归并排序算法，该算法利用分治法思想，时间复杂度为O(NlogN)。文章还讨论了如何通过回调函数实现对不同类型数据的排序，并给出了一个示例，即根据学生考试成绩和姓名字典序进行排序的场景。

排序常见的有十几种排序算法，然而对于单链表来说，链表缺乏随机访问特点，导致一些排序算法在时间和空间复杂度上都比较复杂，一般的冒泡排序与插入排序，其时间复杂度都是O(N^2)。链表中最优的排序算法应该为归并排序，归并排序是分治法的典型应用，主要思想是将一个大问题划分为N（一般取2）个等价的子问题，通过对子问题的解答来达到对原有问题的解决。下面对链表的归并排序用代码实现。归并排序思想可以参考数组归并排序思想，其时间复杂度为O（NlogN)，需要注意的是，对于链表的排序，需要维系一些辅助链表指针，特别注意指针的取值范围。在链表数据量较大时，应该优先考虑此算法排序：

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

#define MAX 20

typedef struct tagListNode
{
    int data;
    struct tagListNode *next;
}LinkList;

LinkList *getMiddleNode(LinkList *pList)
{
    if (pList == NULL)
    {
        return NULL;
    }
    LinkList *pAhead = pList->next;
    LinkList *pBehind = pList;
    while (pAhead != NULL)
    {
         pAhead = pAhead->next;
         if (pAhead != NULL)
         {
             pAhead = pAhead->next;
             pBehind = pBehind->next;
         }

    }

    return pBehind;
}

LinkList *MergeList(LinkList *p1, LinkList *p2) //合并有序链表，合并之后升序排列
{
    if (NULL == p1)
    {
        return p2;
    }
    if (NULL == p2)
    {
        return p1;
    }

    LinkList *pLinkA = p1;
    LinkList *pLinkB = p2;
    LinkList *pTemp = NULL;
    if (pLinkA->data <= pLinkB->data)
    {
        pTemp = pLinkA;
        pLinkA = pLinkA->next;
    }
    else
    {
        pTemp = pLinkB;
        pLinkB = pLinkB->next;
    }

    LinkList *pHead = pTemp; //初始化头结点，即头结点指向不为空的结点
    while (pLinkA && pLinkB)
    {
        if (pLinkA->data <= pLinkB->data)
        {
            pTemp->next = pLinkA;
            pTemp = pLinkA;
            pLinkA = pLinkA->next;
        }
        else
        {
            pTemp->next = pLinkB;
            pTemp = pLinkB;
            pLinkB = pLinkB->next;
        }

    }

    pTemp->next = pLinkA ? pLinkA:pLinkB; //插入多余的链表部分

    return pHead;
}

LinkList *MergeSort(LinkList *pList)
{
    if (pList == NULL || pList->next == NULL)
    {
        return pList;
    }

    LinkList *pMiddle = getMiddleNode(pList); //获取中间结点
    LinkList *pBegin = pList; //链表前半部分，包括中间结点
    LinkList *pEnd = pMiddle->next;//链表后半部分
    pMiddle->next = NULL; //必须赋值为空
    pBegin = MergeSort(pBegin); //排序前半部分数据
    pEnd = MergeSort(pEnd); //排序后半部分数据
    return MergeList(pBegin, pEnd); //合并有序链表
}


LinkList *CreateList(void)
{
    LinkList *pHead = NULL;
    srand(time(NULL));
    int i;
    for (i = 0; i < MAX; i++)
    {
        LinkList *pNode = (LinkList*)malloc(sizeof(*pNode));
        if (pNode == NULL)
        {
            return 0;
        }
        pNode->data = rand() % MAX; //随机产生MAX个数据
        pNode->next = pHead; //采用前插法生成链表
        pHead = pNode;
    }

    return pHead;
}

void traverse(LinkList *pList) //遍历整个链表
{
    while (pList != NULL)
    {
        fprintf(stdout, "%d\n", pList->data);
        pList = pList->next;
    }
    printf("***********************\n");
}


int main()
{
    LinkList *pList = CreateList();
    traverse(pList);
    pList = MergeSort(pList);
    traverse(pList);

    return 0;
}

================================================================================

上面链表合并排序算法只是对整数进行排序，那么能不能对一般类型的数据进行排序呢，答案是肯定的！ 我们可以仿照库函数中的qsort函数接口，提供一个回调函数来指定排序规则。注意qsort一般只能对连续内存进行排序，这里我们可以将上面的函数接口改为：

    LinkList *MergeSort(LinkList *pList, int(*cmp_func)(const void *a, const void *b))

上面的int(*cmp_func)(const void *a, const void *b)为回调函数，实质上指的是排序比较规则由调用者指定。

假设现在有一个需求，班级一共有20名学生，学生信息包括学生id号，学生姓名及考试总成绩(100分制算)。现在需要对学生信息进行排名：学生成绩按照从高分往低分排序，如果两人成绩一样，则按照学生的姓名字典序排序。显然需要修改下排序规则，那么我们对链表数据域类型泛化，只提供一个void *类型的数据，具体由实际类型指定。基于上述排序算法的改进排序算法如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#define MAX 20

typedef struct tagListNode
{
    void *data;
    struct tagListNode *next;
}LinkList;

LinkList *getMiddleNode(LinkList *pList)
{
    if (pList == NULL)
    {
        return NULL;
    }
    LinkList *pAhead = pList->next;
    LinkList *pBehind = pList;
    while (pAhead != NULL)
    {
         pAhead = pAhead->next;
         if (pAhead != NULL)
         {
             pAhead = pAhead->next;
             pBehind = pBehind->next;
         }

    }

    return pBehind;
}

LinkList *MergeList(LinkList *p1, LinkList *p2, int(*cmp_func)(const void *a, const void *b)) //合并有序链表，合并之后升序排列
{
    if (NULL == p1)
    {
        return p2;
    }
    if (NULL == p2)
    {
        return p1;
    }

    LinkList *pLinkA = p1;
    LinkList *pLinkB = p2;
    LinkList *pTemp = NULL;

    if(cmp_func(pLinkA->data, pLinkB->data) <= 0)
    {
        pTemp = pLinkA;
        pLinkA = pLinkA->next;
    }
    else
    {
        pTemp = pLinkB;
        pLinkB = pLinkB->next;
    }

    LinkList *pHead = pTemp; //初始化头结点，即头结点指向不为空的结点
    while (pLinkA && pLinkB)
    {
        if (cmp_func(pLinkA->data, pLinkB->data) <= 0)
        {
            pTemp->next = pLinkA;
            pTemp = pLinkA;
            pLinkA = pLinkA->next;
        }
        else
        {
            pTemp->next = pLinkB;
            pTemp = pLinkB;
            pLinkB = pLinkB->next;
        }

    }

    pTemp->next = pLinkA ? pLinkA:pLinkB; //插入多余的链表部分

    return pHead;
}

LinkList *MergeSort(LinkList *pList, int(*cmp_func)(const void *a, const void *b))
{
    if (pList == NULL || pList->next == NULL)
    {
        return pList;
    }

    LinkList *pMiddle = getMiddleNode(pList); //获取中间结点
    LinkList *pBegin = pList; //链表前半部分，包括中间结点
    LinkList *pEnd = pMiddle->next;//链表后半部分
    pMiddle->next = NULL; //必须赋值为空
    pBegin = MergeSort(pBegin, cmp_func); //排序前半部分数据
    pEnd = MergeSort(pEnd, cmp_func); //排序后半部分数据
    return MergeList(pBegin, pEnd, cmp_func); //合并有序链表
}

typedef struct
{
    int id;
    char name[20];
    int score;
}student_t;

int cmp(const void *a, const void *b)
{
    student_t *pa = (student_t *)a;
    student_t *pb = (student_t *)b;
    if(pa->score != pb->score)
    {
        return pb->score - pa->score;
    }
    else
    {
        return strcmp(pa->name, pb->name) > 0;
    }

}

LinkList *CreateDataList(void)
{
    LinkList *pHead = NULL;
    srand(time(NULL));

    for (int i = 0; i < MAX; i++)
    {
        LinkList *pNode = (LinkList*)malloc(sizeof(*pNode));
        if (pNode == NULL)
        {
            return 0;
        }
        //随机产生MAX个数据
        student_t *pt = (student_t*)malloc(sizeof(student_t));
        pt->id = i + 1;
        int len = 0;
        for (int k = 0; k < 10; k++)
        {
            len += sprintf(pt->name + len, "%c", rand() % 25 + 'a');
        }
        pt->score = rand() % 40 + 60;
        pNode->data = (void*)pt;
        pNode->next = pHead; //采用前插法生成链表
        pHead = pNode;
    }
    return pHead;
}

void traverseList(LinkList *pList) //遍历整个链表
{
    while (pList != NULL)
    {
        student_t *pt = (student_t *)pList->data;
        fprintf(stdout, "%d:%s:%d\n", pt->id, pt->name, pt->score);
        pList = pList->next;
    }
    printf("***********************\n");
}




int main()
{
    LinkList *pList = CreateDataList();
    traverseList(pList);
    pList = MergeSort(pList, cmp);
    traverseList(pList);

    return 0;
}
代码运行结果如下图，正如我们所期望的，排序算法满足预期要求：

单链表进行归并排序
yang20141109的专栏
04-30 1267
对单链表进行归并排序：首先设置两个指针slow和fast，slow指针每次走一步，fast指针每次走两步，当fast指向末尾元素或者指向空时，slow指针刚好走到链表的中间位置，此时slow指针恰好把链表分为左右两部分，slow->next指针指向第二部分的首部，然后我们递归的对两部分进行划分操作，最后划分到两部分都只有一个元素时，我们对其进行合并操作，然后依次递归的向上进行归并操作。时间复杂度为
单链表归并排序 --自底向上 & 自顶向下
oneslide
03-15 721
引入一个指针dummy作为链表的头节点，prev作为这个链表的最后一个节点。[dummy, prev]之间的元素全是局部有序的。局部如何有序，取决于intv的长度。比如当intv =1 时，先排序3和4，组成一个局部有序区间[3,4] 追加到prev后面，prev指向4;那么经过第一轮合并，dummy链表是两两有序的。那么下一轮，就可以开始合并两个元素的子链表了。再排序2和6时，组成一个局部区间[2,6], 追加到prev后面，prev指向6.通过合并排序将两个有序链表合并成一个是比较简单的。
软考下午题UML类图拿分秘籍：从聚合组合到泛化，手把手教你识别关键关系
最新发布
weixin_30381317的博客
05-27 637
本文深入解析软考UML类图考试中的聚合、组合、泛化等核心关系，提供真题破解四步法和高频考点剖析。通过图形符号识别、题干定位、名词提取和逻辑验证，帮助考生快速掌握15分必考题的解题技巧，特别针对聚合与组合的生命周期差异、泛化关系识别等难点给出实用口诀和示例分析。
单链表的快速排序与归并排序
FinixLei的专栏 (https://github.com/FinixLei)
07-27 9412
本文经过2次更新，共介绍了单链表快速排序的2种方法以及单链表的归并排序
对单链表进行归并排序（Java实现）
weixin_45685353的博客
12-25 1461
概述： 在上一篇中，讲解了如何对单链表进行快速排序，这一篇将介绍如何对单链表进行归并排序，对归并排序不熟悉的小伙伴可以先去了解归并排序的实现。那怎样对一单链表进行归并排序呢？下面开始逐步介绍。 实现： 首先定义单链表的节点， private static class Node { public int val; public Node next; public Node(int val) { this.val = val;
对单链表的归并排序的C++实现
Hikers、Wan的博客
02-28 885
前言 记录用C++实现基于单链表的归并排序 代码 一共三个文件SingleLinkedList.h, CNode.h以及main.cpp。 首先是CNode.h #ifndef _NODE_H__ #define _NODE_H__ class CNode{ private: int data; CNode *nextNode; public: CNode(); void setData...
自然归并排序和单链表实现的归并排序
github_38283106的博客
06-16 952
自然归并排序 （1）思路： 1、找出需要排序数组中的所有有序子数组，将每个子数组的起始下标存在一个辅组数组中，假设为mark[]。 2、将有序字数组两两归并，最后得到有序数组。 3、需要注意被排序数组的长度N （2）代码public class NatureMerge extends Sort { public static > int pass(T[] arr, int[] mark
Java单链表归并排序
杜鲁门的博客
02-24 5054
概念归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用，归并排序将两个已排序的表合并成一个表。归并排序基本原理通过对若干个有序结点序列的归并来实现排序。 所谓归并是指将若干个已排好序的部分合并成一个有序的部分。单链表实现归并排序找到中间点拆分链表//找到中间点，然后分割 public ListNode getMid
用归并排序实现单链表的排序
木东的博客
05-14 2014
今天做了百度的一套数据挖掘的笔试题，其中有一道对单链表进行归并排序，因为刚学归并排序的时候是针对数组来说，所以这道题着实费了一点心思。 考点：1归并算法2单双步求中点3链表指针的操作，以及边界空指针问题4内存分配与回收； 单链表与数组相比只能顺序访问每个元素，因此在使用二路归并排序时关键在于找到链表的中间结点将链表一分为二：可以利用快慢指针同时遍历单链表，当步长为2的指针 指向链表最后一个结
写给自己看的单链表(5)：归并排序
随便写写
03-21 522
！！！Attention：以下操作中的单链表均带有头结点！！！
单链表的归并排序
try to do
11-06 1810
转自 https://blog.csdn.net/u010853261/article/details/54884650 Question: 148. Sort List Sort a linked list in O(n log n) time using constant space complexity. 中文：使用恒定的空间复杂度排序一个链表，要求时间复杂度是O(nlogn) 我们知道...
【leetcode 单链表归并排序】Sort List
wepon的专栏
11-09 2935
1、题目 2、分析 3、归并排序代码 4、快速排序代码
单链表的快速排序和归并排序
linshengchao123的专栏
09-25 789
大家可能对一维数组的快速排序和归并排序比较熟悉，但是dan
单链表排序的最优时空算法——归并排序
qq_43840665的博客
07-08 1636
排序 时间复杂度O(nlog2 n)，空间复杂度为O(1) 算法思想： 1. 分，把链表不断划分成两个子链表，直到子链表中只含有一个元素，认为其是 有序的 2.治，它将两个有序数组合并成一个更大的有序数组 /* 快慢指针：常用于判断链表中是否有环，简单来说就是有两个指针，快指针每次走两个节点，慢指针每次走一个节点，当快指针走到链表尽头时，慢指针才走到了链表的一半，此时就是我们想要的中间节点 */ 代码： //链表结构体 typedef int ElemType ; struct Node{
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值