148. Sort List

最新推荐文章于 2023-05-30 19:46:57 发布

Raintin_coder

最新推荐文章于 2023-05-30 19:46:57 发布

阅读量210

点赞数

CC 4.0 BY-SA版权

分类专栏： C++ leetcode

本文链接：https://blog.youkuaiyun.com/qq_29592167/article/details/82530600

C++ 同时被 2 个专栏收录

45 篇文章

订阅专栏

leetcode

37 篇文章

订阅专栏

本文深入探讨了链表排序的两种高效方法：归并排序和快排与归并结合的策略。通过具体代码示例，详细讲解了如何利用归并排序的拆分合并思想以及快速排序的分区思想来实现链表的有序排列。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这道题说实在的挺难的，到现在为止我都不熟练，而且当时真的没有思路，所以，把大神的思路拿来看了看，才略懂一点。

题的大意是这样的，对一组无序链表进行排序，我们比较熟悉的是数组排序，现在让用链表排序，确实还挺懵的，刚开始是将链表中所有元素的地址放在一个vector当中，把链表排序当作数组排序，但不符合题目的要求。

看了大神的思路，一般有两种，因为是链表，最大的难度在于无法快速定位元素，所以，把链表拆的短一点就好操作了，这是典型的归并排序的思维，先拆分，再合并。使用归并排序的代码如下：

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (head == NULL || head->next == NULL) {
            return head;
        }
        
        ListNode* head1 = head;
        ListNode* head2 = findMid(head);
        head1 = sortList(head1);
        head2 = sortList(head2);
        return listmergeSort(head1, head2);
    }
    
    ListNode* listmergeSort (ListNode* head1, ListNode* head2) {
        ListNode* listhead = new ListNode(-1);
        ListNode* listtail = listhead;
        
        while (head1!=NULL && head2!=NULL) {
            if (head1->val <= head2->val) {
                listtail->next = head1;
                head1 = head1->next;
            } else {
                listtail->next = head2;
                head2 = head2->next;
            }
            listtail = listtail->next;
            //listtail->next = NULL;
        }
        
        if (head1 != NULL) {
            listtail->next = head1;
        }
        if(head2 != NULL) {
            listtail->next = head2;
        }
        
        return listhead->next;
    }
    
    ListNode* findMid (ListNode* head) {
        ListNode* slow = head->next;
        ListNode* fast = head->next;
        ListNode* preslow = head;
        
        while (fast->next && fast->next->next) {
            fast = fast->next->next;
            preslow = slow;
            slow = slow->next;
        }
        preslow->next = NULL;
        
        return slow;
    }
};

还有一种是使用快排和归并相结合的方式，我们知道，快排的最终结果是将小于目标元素的数放在左边，比目标元素大的数放在右边，和目标元素相等的数自然而然就在中间，所以，实际上数组是三部分组成，大于目标元素，小于目标元素，等于目标元素，这三部分分别用三个新指针去重新构成新的链表，这三部分只有相等的部分是排序好的，其他小于目标元素部分和大于目标元素部分都是无序的，需要继续使用归并的方式进行分裂，然后继续执行上述方法，最后，在统一将所有的元素顺序结合起来，代码如下：

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        if (head==NULL || head->next==NULL) {
            return head;
        }
        
        return quickSort(head);
    }
    
    ListNode* quickSort(ListNode* head) {
        if (head==NULL || head->next==NULL) {
            return head;
        }
        
        ListNode* cur = head;
        ListNode* smallnode = new ListNode(0);
        ListNode* bignode = new ListNode(0);
        ListNode* equalnode = new ListNode(0);
        ListNode* psnode = smallnode;
        ListNode* pbnode = bignode;
        ListNode* penode = equalnode;
        
        while (cur!=NULL) {
            if (cur->val > head->val) {
                pbnode->next = cur;
                pbnode = pbnode->next;
            } else if (cur->val < head->val) {
                psnode->next = cur;
                psnode = psnode->next;
            } else {
                penode->next = cur;
                penode = penode->next;
            }
            cur = cur->next;
        }
        psnode->next = NULL;
        penode->next = NULL;
        pbnode->next = NULL;
        
        return mergeSort(quickSort(smallnode->next), mergeSort(equalnode->next, quickSort(bignode->next)));
    }
    
    ListNode* mergeSort (ListNode* smallnode, ListNode* bignode) {
        if (smallnode == NULL) {
            return bignode;
        }
        
        if (bignode == NULL) {
            return smallnode;
        }
        
        ListNode* mergenode = smallnode;
        while (smallnode->next != NULL) {
            smallnode = smallnode->next;
        }
        smallnode->next = bignode;
        return mergenode;
    }
};