LeetCode100之排序链表(148)--Java

1.问题描述

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

        示例1

输入：head = [4,2,1,3]
输出：[1,2,3,4]

        示例2 

输入：head = [-1,5,3,4,0]
输出：[-1,0,3,4,5]

        示例3 

输入：head = []
输出：[]

        提示

• 链表中节点的数目在范围 [0, 5 * 104] 内
• -105 <= Node.val <= 105

        难度等级

                中等

        题目链接

        排序链表

2.解题思路

        这道排序链表的题目，考察的是如何将排序算法用到链表上。这里，我选择了归并排序，因为归并排序在不使用其他太多额外空间的情况下，处理起来相对比较简单和容易理解。

        在正式开始排序之前，我们可以先做一个校验。如果链表为空了或者链表只有一个元素，那么就没有排序的必要了，直接返回就可以了。

        if(head == null || head.next == null){
            return head;
        }

        接着，我们就可以开始归并排序的第一步:分。我们要将链表切分成很多小链表，最简单的排序，当然就是只有两个节点的时候，比较一次大小就可以分出先后了。所以我们要不断的切分切分再切分。

        这里最简单的方法就是从链表的中间切，我们可以定义一个中间指针和一个尾指针，中间指针初始化为head(头指针)，尾指针初始化为head.next(链表的第二个节点)，这里之所以这么初始化，是为了防止后续递归切分时陷入死循环。接着，中间指针遍历一个节点的同时，尾指针遍历两个节点，这样当尾指针到达链表末尾时，中间指针也就到达了遍历中部。

        //头尾指针，用于分割链表
        ListNode mid = head;
        //必须是头指针的下一个，不然会在分割的时候陷入死循环
        ListNode tail = head.next;
        //循环找到要分割的位置
        while(tail != null && tail.next != null){
            tail = tail.next.next;
            mid = mid.next;
        }

        现在，链表就被我们用中间指针分成了两部分。这时，我们还需要一个指针来保存第二部分链表的头结点，接着将中间指针所在节点的next指针设置为空。这样就将一个链表切分成了两个链表了。然后，我们将获得的两个链表分别递归调用当前方法，就可以或者很多个小链表了。在切分链表的代码逻辑后面，我们还有对切分后了链表进行"归"的合并操作，最终返回一个有序链表的头结点。所以，我们递归之后是可以获得已经排序好后的小链表的。

        //临时存储第二部分的头指针
        ListNode secondHead = mid.next;
        //分割
        mid.next = null;
        //递归分割并排序
        ListNode left = sortList(head);
        ListNode right = sortList(secondHead);
        if(left == null){
            return right;
        }
        if(right == null){
            return left;
        }

        完成了"分"操作之后，我们就要了完成“归”操作了。合并操作就是将两个小链表进行合并，定义一个新的头结点和链表指针，用一个while循环来合并两个小链表。每一次循环，比较两个小链表的头指针的值，将较小的节点取出来合并到新链表中。当循环退出时，意味着其中一个小链表已经合并完成了，接着，我们只需要将另一个小链表剩余部分，添加到新链表的末尾，即可完成合并。

        //新的头指针
        ListNode newHead = new ListNode(0);
        ListNode p = newHead;
        //归并
        while(left != null && right != null){
            if(left.val < right.val){
                p.next = left;
                left = left.next;
            }else{
                p.next = right;
                right = right.next;
            }
           p = p.next;
        }
        p.next = left != null ? left : right;

        最后，将新链表的头结点返回即可。

3.代码展示

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null){
            return head;
        }
        //头尾指针，用于分割链表
        ListNode mid = head;
        //必须是头指针的下一个，不然会在分割的时候陷入死循环
        ListNode tail = head.next;
        //循环找到要分割的位置
        while(tail != null && tail.next != null){
            tail = tail.next.next;
            mid = mid.next;
        }
        //临时存储第二部分的头指针
        ListNode secondHead = mid.next;
        //分割
        mid.next = null;
        //递归分割并排序
        ListNode left = sortList(head);
        ListNode right = sortList(secondHead);
        if(left == null){
            return right;
        }
        if(right == null){
            return left;
        }
        //新的头指针
        ListNode newHead = new ListNode(0);
        ListNode p = newHead;
        //归并
        while(left != null && right != null){
            if(left.val < right.val){
                p.next = left;
                left = left.next;
            }else{
                p.next = right;
                right = right.next;
            }
           p = p.next;
        }
        p.next = left != null ? left : right;
        //返回头结点
        return newHead.next;
    }
}

4.总结

        这道题，我们采用归并排序的方法来进行链表的排序，唯一要值得注意的点就是，在切分小链表时，尾指针的初始化值要初始化为头指针的下一个节点，这样递归调用时才不会陷入死循序。今天这道题就啰嗦到这了，祝大家刷题愉快~