LeetCode 148——排序链表

1. 题目

2. 解答

2.1 快速排序

可参考 快速排序和归并排序 中的第一种快速排序思想，与在数组中排序有两点不同。

第一，我们需要取最后一个元素作为主元，在数组中可以直接访问到最后一个元素，但在单链表中，我们需要先遍历一遍链表才能访问到最后一个元素。

第二，在数组中，利用主元将数组划分为左右两个部分后，我们可以用下标来递归调用，但在链表中，我们改用头指针和尾指针来标识左右两个部分。如下图所示，左半部分头指针为 head，尾指针为 p1；右半部分头指针为 p1-next，尾指针为 end。

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        
        if(head == NULL)    return head;
        Quick_Sort(head, NULL);
        return head;    
    }
    
    void Quick_Sort(ListNode* head, ListNode* end)
    {
        if (head != end && head->next != end)
        {
            ListNode* ptr = head;
            while(ptr->next != end) ptr = ptr->next; // 取链表最后一个元素作为主元
            int pivot = ptr->val;
            
            ListNode* p1 = head;
            ListNode* p2 = head;
            
            while(p2->next != end)
            {
                if(p2->val < pivot)
                {
                    int temp = p2->val;
                    p2->val = p1->val;
                    p1->val = temp;
                    p1 = p1->next;
                }
                p2 = p2->next;
            }
            p2->val = p1->val;
            p1->val = pivot;
            Quick_Sort(head, p1); // 此时 p1 指向 pivot，前一半链表头为 head，尾为 p1
            Quick_Sort(p1->next, end); // 后一半链表头为 p1->next，尾为 end
        }
    }

2.2 归并排序

可参考 快速排序和归并排序 中的归并排序思想，主要有三个步骤。

• 找到链表的中间结点
• 递归对左半部分和右半部分排序
• 合并排序好的两部分链表，这部分因为不能使用额外空间，我们就将一个链表插入到另一个链表中去

class Solution {
public:
    ListNode* sortList(ListNode* head) {
        
        return  Merge_Sort(head);
    }
    
    ListNode* Merge_Sort(ListNode* head)
    {
        ListNode * mid = Find_Mid(head);
        if (mid)
        {
            ListNode* right_head = mid->next;
            mid->next = NULL;
            ListNode* left_head = Merge_Sort(head);
            right_head = Merge_Sort(right_head);
            head = Merge_List(left_head, right_head);
        }
        return head;
    }
    
    ListNode* Merge_List(ListNode* left_head, ListNode* right_head)
    {
        ListNode* l1 = left_head;
        ListNode* l2 = right_head;
        if (left_head->val > right_head->val)
        {
            l1 = right_head;
            l2 = left_head;
        }
        // l1 指向第一个节点值较小的链表，然后将 l2 中的每个节点插入到 l1 中
        ListNode* p1 = NULL;
        ListNode* head = l1;
        while (l1->next && l2)
        {
            if (l1->next->val > l2->val)
            {
                p1 = l1->next;
                l1->next = l2;
                l2 = l2->next;
                l1 = l1->next;
                l1->next = p1;
            }
            else
            {
                l1 = l1->next;
            }
        }
        if (l2) l1->next = l2; //若 l2 还有节点直接插入到 l1 后面即可
        
        return head;
    }
    
    ListNode* Find_Mid(ListNode* head)
    {
        if (head == NULL || head->next == NULL) return NULL;
        
        ListNode* slow = head;
        ListNode* fast = head;
        while (fast->next != NULL && fast->next->next != NULL)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }
        
};

获取更多精彩，请关注「seniusen」!