Sort List---148---链表排序(归并)

题目描述:给链表排序

input : 4->2->1->3 output : 1->2->3->4

思路:要求在O(nlgn)时间复杂度内,合适的排序方法快排,堆排,归并,还有O(n)的基数排序桶排序
链表的特点不能通过下标访问,堆排一般是数组形式,所以最好采用归并排序(递归操作)
温故而知新:回顾下归并排序,将两个已经排好序的序列合并成一个有序序列merge,有递归和非递归两种,两路归并就是两两合并
那么对于无序链表来说,怎么才是有序链表,当然是只有一个节点的是有序链表
所以就把问题不断分解,直到链表内只有一个节点
一个链表不断分成两半,直到分到只有一个节点,然后往上回溯,合并,调用合并有序链表
链表分成两个中点使用快慢指针法,快指针走两步,慢指针走一步,当快指针走到末尾,慢指针就来到链表中点

#include<iostream>

using namespace std;
struct ListNode{
    int data;
    ListNode* next;
    ListNode(int x) : data(x), next(NULL){}
};
void show(ListNode* head)
{
    if(head == NULL)
    {
        cout << "NULL";
    }
    ListNode* p = head;
    while(p)
    {
        cout << p->data;
        p = p->next;
    }
    cout << endl;
}
ListNode* createList(int n)//尾插法创建链表
{
    ListNode* head = new ListNode(0);
    ListNode* newNode;
    ListNode* rear = head;
    for(int i = 0; i < n; i++)
    {
        int data;
        cin >> data;
        newNode = new ListNode(data);
        rear->next= newNode;
        rear = newNode;
    }
    rear->next = NULL;
    return head->next;
}
class Solution{
public:
    ListNode* sortList(ListNode* head)
    {
        if(!head || !head->next) return head;
        ListNode* fast = head, *slow = head, *pre = head;
        while(fast && fast->next)//快指针走两步慢指针走一步,快指针走到链表末尾,慢指针刚好走到中间位置
        {
            pre = slow;
            slow = slow->next;
            fast = fast->next->next;
        }
        pre->next = NULL;
        return mergeList(sortList(head), sortList(slow));
    }
    ListNode* mergeList(ListNode* l1, ListNode* l2)//合并链表
    {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        ListNode* dummy = new ListNode(0);
        ListNode* head = dummy;
        while(l1 && l2)
        {
            if(l1->data < l2->data)
            {
                head ->next = l1;
                l1 = l1->next;
            }
            else{
                head->next = l2;
                l2 = l2->next;
            }
            head = head->next;            
        }
        head ->next = l1 ? l1 : l2;
        return dummy->next;
    }

};
int main()
{
    ListNode* l = createList(4);
    show(l);
    Solution s;
    ListNode *l1 = s.sortList(l);
    show(l1);
    return 0;
}
C++实现2-归并排序通常用于处理链表这种数据结构,因为传统的数组操作不适合。2-归并排序可以将链表分为两个独立的部分进行递归排序,然后合并它们。这里是一个简单的步骤概述: 1. **划分**:首先,将链表分成两半,这通常通过快慢指针法实现。 2. **递归排序**:对每个半部分分别进行递归的2-归并排序。 3. **合并**:当两个链表都被排序后,创建一个新的合并过程,比较两个链表的头节点,将较小的节点添加到结果链表,并更新指向下一个未处理节点的指针,直到其中一个链表为空,然后将另一个链表剩余的部分直接添加到结果链表。 4. **返回结果**:递归结束,最后得到的链表就是排序后的结果。 以下是伪代码形式: ```cpp struct ListNode { int val; ListNode* next; // ListNode 构造省略... }; ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) { if (!l1) return l2; if (!l2) return l1; if (l1->val < l2->val) { l1->next = mergeTwoLists(l1->next, l2); return l1; } else { l2->next = mergeTwoLists(l1, l2->next); return l2; } } ListNode* sortList(ListNode* head) { if (!head || !head->next) return head; // 如果链表只有一个元素或为空,直接返回 ListNode* slow = head; ListNode* fast = head->next; while (fast && fast->next) { slow = slow->next; fast = fast->next->next; } ListNode* secondHalf = slow->next; slow->next = nullptr; // 分割头部与后半部分 return mergeTwoLists(sortList(head), sortList(secondHalf)); } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值