LeetCode 148. 排序链表-Java题解(归并排序)

题目

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

进阶：
你可以在 O(n*log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

看到O(n*log n)复杂度，不难想出，可以用归并排序来完成，但这与平时的归并排序又存在不同之处

通过这张图可以看出典型归并的递归过程，先分割再合并，通常问题中可以说数据本身就是分割的，但链表并非如此，所以合并之前需要再添加一个环节，即分割环节

想要分割就要找到链表的中点，这又涉及到了链表中点问题，使用典型的双指针思想就能解决，这里不再赘述。

下面附上递归代码：

class Solution {
    public ListNode sortList(ListNode head) {
        ListNode dummyHead=new ListNode(0);
        dummyHead.next=head;

        ListNode p=head;
        int length=0;
        while(p!=null){
            length++;
            p=p.next;
        }

		if(head==null||head.next==null)
            return head;
        
        //求当前链表中点
        ListNode fast=head.next;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
		//切割并递归排序左右链表
        ListNode temp=slow.next;
        slow.next=null;
        ListNode left=sortList(head);
        ListNode right=sortList(temp);

		//合并链表
        ListNode h=new ListNode(0);
        ListNode res=h;
        while(left!=null&&right!=null){
            if(left.val<right.val){
                h.next=left;
                left=left.next;
            }else{
                h.next=right;
                right=right.next;
            }
            h=h.next;
        }

        h.next=left!=null?left:right;
        return res.next;
    }
}

这种递归解法很典型，时间复杂度为O(n* log n)。但由于递归栈深度为logn，所以空间复杂度也为O(n*log n) ，这与题目要求的常量复杂度不符， 需要使用非递归的归并排序。

非递归代码及注释：

class Solution {
    public ListNode sortList(ListNode head) {
        ListNode dummyHead=new ListNode(0);
        dummyHead.next=head;

		//求链表长度
        ListNode p=head;
        int length=0;
        while(p!=null){
            length++;
            p=p.next;
        }

		//核心代码
		//size表示当前要排序的链表大小，类似于上图中的下半部分，所以size=size<<1也就理解了
        for(int size=1;size<length;size=size<<1){
        	//由于不能递归，所以每次的切割和合并都要从链表头开始，所以要进行初始化
            ListNode cur=dummyHead.next;//注意这里不能为head，因为在排序过程中，head可能就不在为链表头了
            ListNode tail=dummyHead;//tail是切割链表后链表，前半部分的尾节点，它的存在是为了连接前后链表

			//在while中实现一次整体的切割和合并
            while(cur!=null){
            	//其实当前tail是指向left之前链表的尾的
            	//这是切割好的第一个链表的头节点
                ListNode left=cur;
                //这是切割好的第二个链表的头节点
                ListNode right=cut(left,size);
				//剩余链表的头节点
                cur=cut(right,size);

				//当前链表分为了四部分，以tail为尾的已经合并好的链表，和分别以left，right，cur为头
				//将要排序的left和right合并排序并和之前的链表连接
                tail.next=merger(left,right);
                while(tail.next!=null){//tail向后转移
                    tail=tail.next;
                }
            }
        }
        //结束
        return dummyHead.next;
     }

	//从head切割size个节点，并返回切割后剩余的链表
	ListNode cut(ListNode head,int size){
        ListNode p=head;
        while(--size>0&&p!=null){
            p=p.next;
        }
        if(p==null) return null;
        ListNode next=p.next;
        p.next=null;
        return next;
    }

    ListNode merger(ListNode list1,ListNode list2){
        ListNode dummyHead = new ListNode(Integer.MIN_VALUE), p = dummyHead;
        while(list1 != null && list2 != null){
            if(list1.val < list2.val){
                p.next = list1;
                list1 = list1.next;
            } else{
                p.next = list2;
                list2 = list2.next;
            }
            p = p.next;
        }
        if(list1 == null){
            p.next = list2;
        } else{
            p.next = list1;
        }
        return dummyHead.next;
    }
}

完成这道题，我们运用了非递归和递归的归并排序，双指针思想，以及dummyHead的应用（dummyHead在链表操作中很有用，鄙人太菜，以后有时间再系统学习学习…），所以我认为这道题很经典，也很值得记录。

参考：https://leetcode-cn.com/problems/sort-list/solution/sort-list-gui-bing-pai-xu-lian-biao-by-jyd/