148. Sort List-优快云博客

本文链接：https://blog.youkuaiyun.com/BigFatSheep/article/details/84102645

本文介绍了一种在O(nlogn)时间内对链表进行排序的方法，使用常数空间复杂度，通过模仿归并排序的思想，将链表分为两部分，递归地排序每一部分，然后合并两个有序链表。

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

Description

Sort a linked list in O(n log n) time using constant space complexity.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4
Example 2:

Input: -1->5->3->4->0
Output: -1->0->3->4->5
Problem URL

Solution

给一个链表，要求在O（nlogn）时间内排序，并使用常数空间，相当于in-place。

We use the thought of merge sort to solve this problem

First, split the list into left and right two parts. Using slow, fast and prev pointers to realize it. prev = null set the list into two part.

Second, recursively call sortList() to left and right parts. So the list would be split to nodes.

Third, use mergeList() to merge the two list together.

In mergetList, we create a dummy head as the head of the new list. After that is the process of merget two sorted list. Use a cur pointer to add l1 or l2 nodes one by one. Then add rest nodes of l1 or l2.

Code

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        //1.split the list into two parts
        ListNode fast = head, slow = head, prev = null;
        while (fast != null && fast.next != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        //2.sort left and right recursively
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        //3.merget the two list together
        return mergeList(l1, l2);
        
    }
    
    public ListNode mergeList(ListNode l1, ListNode l2){
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        while (l1 != null && l2 != null){
            if (l1.val < l2.val){
                cur.next = l1;
                l1 = l1.next;
            }
            else{
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        if (l1 == null){
            cur.next = l2;
        }
        if (l2 == null){
            cur.next = l1;
        }
        return dummy.next;
    }
}

Time Complexity: O(nlogn)
Space Complexity: O(1)

Review

Recursively version of mergeList

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if (head == null || head.next == null){
            return head;
        }
        //1.split the list into two parts
        ListNode fast = head, slow = head, prev = null;
        while (fast != null && fast.next != null){
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        //2.sort left and right recursively
        ListNode l1 = sortList(head);
        ListNode l2 = sortList(slow);
        //3.merget the two list together
        return mergeList(l1, l2);
        
    }
    
    public ListNode mergeList(ListNode l1, ListNode l2){
        if (l1 == null){
            return l2;
        }
        if (l2 == null){
            return l1;
        }
        if (l1.val < l2.val){
            l1.next = mergeList(l1.next, l2);
            return l1;
        }
        else{
            l2.next = mergeList(l1, l2.next);
            return l2;
        }
    }
}