leetcode--sort-list（归并排序）

sort-list

描述

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

代码

设置两个指针，一个步长为1， 一个步长为2，当快指针到达尾结点时，慢指针指向中间结点，时间复杂度为O(N)；

平分为左链表L1和右链表L2，递归分裂，直到链表为空或者只有一个结点；

将链表L2的每个结点插入到链表L1中，时间复杂度为O(m+n)，m、n分别为两条链表的长度。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode merge(ListNode left,ListNode right){
        ListNode head=new ListNode(-1);
        head.next=left;
        ListNode p=head;
        while(left!=null&&right!=null){
            if(left.val>=right.val){
                ListNode pr=right;
                right=right.next;
                pr.next=p.next;
                p.next=pr;
                p=pr;
            }else{
                p=left;
                left=left.next;
            }
        }
        if(right!=null){
            p.next=right;
        }
        return head.next;
    }
    public ListNode sortList(ListNode head) {
        if(head==null||head.next==null){
            return head;
        }
        ListNode fast=head,slow=head;
        while(slow.next!=null&&fast.next!=null&&fast.next.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        ListNode rightHead=slow.next;
        ListNode leftHead=head;
        slow.next=null;
        leftHead=sortList(leftHead);
        rightHead=sortList(rightHead);
        return merge(leftHead,rightHead);
    }
}