力扣148——排序链表

Posted death00

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了力扣148——排序链表相关的知识,希望对你有一定的参考价值。

原题

在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。

示例 1:

输入: 4->2->1->3
输出: 1->2->3->4

示例 2:

输入: -1->5->3->4->0
输出: -1->0->3->4->5

原题url:https://leetcode-cn.com/problems/sort-list/

解决

题目很明确,排序,对于时间复杂度和空间复杂度有要求,针对O(n log n),让我想到了归并排序快速排序,接下来我们各自来看看。

对了,这里先统一放一下节点类,单向链表中的节点,存储当前节点的值和后一个节点的引用。

Definition for singly-linked list.
public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

归并排序

归并排序,说白了,就是先分解到最小单元,然后逐个进行合并并排序,这样在合并的时候,其实两个链表本身就是有序的,那么当有一个全部取完后,另一个可以直接拼接在最后面。

让我们看一下代码:

public class Solution {
    public ListNode sortList(ListNode head) {
        // 归并排序
        
        if (head == null || head.next == null) {
            return head;
        }

        // 先分隔,利用快慢指针分隔。
        // 快指针先走,因为只有当空节点或1个节点才是终止条件,2个节点的时候,如果不让快指针先走,而是也指向head,那么2个节点永远不会被分隔,会陷入死循环
        ListNode fast = head.next.next;
        ListNode slow = head;
        while (true) {
            if (fast == null || fast.next == null) {
                break;
            }

            fast = fast.next.next;
            slow = slow.next;
        }
        // 后半部分的开头
        ListNode second = slow.next;
        second = sortList(second);
        // 前半部分的开头
        slow.next = null;
        ListNode first = head;
        first = sortList(first);

        // 合并
        ListNode result = new ListNode(0);
        head = result;
        while (first != null && second != null) {
            if (first.val < second.val) {
                result.next = first;
                first = first.next;
            } else {
                result.next = second;
                second = second.next;
            }
            result = result.next;
        }
        if (first != null) {
            result.next = first;
        } else {
            result.next = second;
        }

        return head.next;
    }
}

提交OK,执行用时:5 ms,内存消耗:39.6 MB,执行用时只战胜了59.07%的 java 提交记录,应该还有优化的空间。

归并排序——优化

针对上面的代码,在分隔的时候,设置fast = head.next.next,这是因为我们设置的递归终止条件是针对null或者单个节点的。其实当只剩下两个节点的时候,就可以进行排序了,这样应该可以节省近一半的时间,当然了,从时间复杂度上来说并没有改变。

我们看一下代码:

public class Solution {
    public ListNode sortList(ListNode head) {
        // 归并排序
        if (head == null || head.next == null) {
            return head;
        }

        // 说明只有两个节点
        if (head.next.next == null) {
            ListNode second = head.next;
            if (head.val > second.val) {
                return head;
            } else {
                second.next = head;
                head.next = null;
                return second;
            }
        }

        // 先分隔,利用快慢指针分隔。
        ListNode fast = head;
        ListNode slow = head;
        while (true) {
            if (fast == null || fast.next == null) {
                break;
            }

            fast = fast.next.next;
            slow = slow.next;
        }
        // 后半部分的开头
        ListNode second = slow.next;
        second = sortList(second);
        // 前半部分的开头
        slow.next = null;
        ListNode first = head;
        first = sortList(first);

        // 合并
        ListNode result = new ListNode(0);
        head = result;
        while (first != null && second != null) {
            if (first.val < second.val) {
                result.next = first;
                first = first.next;
            } else {
                result.next = second;
                second = second.next;
            }
            result = result.next;
        }
        if (first != null) {
            result.next = first;
        } else {
            result.next = second;
        }

        return head.next;
    }
}

执行用时,有的时候是4 ms,有的时候是3 ms,看来归并排序这条路差不多就是这样了。

快速排序

快速排序的思想就是选择一个标准值,将比它大的和比它的小的,做交换。针对链表这种结构,就是将比它大的放在一个链表中,比它小的放在一个链表中,和它一样大的,放在另一个链表中。然后针对小的和大的链表,继续排序。最终将三个链表按照小、相等、大进行连接。

接下来让我们看看代码:

class Solution {
        public ListNode sortList(ListNode head) {
            // 利用快排

            // 单个节点是终止节点
            if (head == null || head.next == null) {
                return head;
            }
            // 比标准值小的节点
            ListNode lowHead = new ListNode(0);
            ListNode low = lowHead;
            // 和标准值一样的节点
            ListNode midHead = new ListNode(0);
            ListNode mid = midHead;
            // 比标准值大的节点
            ListNode highHead = new ListNode(0);
            ListNode high = highHead;

            // 标准值
            int val = head.val;
            ListNode node = head;
            // 遍历
            while (node != null) {
                // 比标准值大的节点
                if (node.val > val) {
                    high.next = node;
                    high = high.next;
                }
                // 比标准值小的节点
                else if (node.val < val) {
                    low.next = node;
                    low = low.next;
                }
                // 和标准值一样的节点
                else {
                    mid.next = node;
                    mid = mid.next;
                }
                node = node.next;
            }
            // 终止,避免造成环
            low.next = null;
            high.next = null;

            lowHead.next = sortList(lowHead.next);
            highHead.next = sortList(highHead.next);

            // 找出小节点链表的末尾
            low = lowHead;
            while (low.next != null) {
                low = low.next;
            }
            // 拼接
            low.next = midHead.next;
            mid.next = highHead.next;

            return lowHead.next;
        }
    }

提交OK,执行用时:2 ms,内存消耗:40.01 MB

和归并排序相比,时间更短,至于原因,我确实是没有想明白,因为都需要比较,然后重新构造新链表。我猜测是测试数据离散程度更高,这样归并排序的话,并没有充分利用其特性:

当两个链表合并时,如果一个链表已经全部结束,另一个链表剩余的部分可以直接拼接。

总结

以上就是这道题目我的解答过程了,不知道大家是否理解了。针对它的时间复杂度要求,利用归并排序或者快速排序解决。

有兴趣的话可以访问我的博客或者关注我的公众号、头条号,说不定会有意外的惊喜。

https://death00.github.io/

公众号:健程之道

技术图片

技术图片

以上是关于力扣148——排序链表的主要内容,如果未能解决你的问题,请参考以下文章

[Leetcode]148. 排序链表(归并排序)

148.排序链表

148-链表排序

leetcode148 排序链表(Medium)

LeetCode Algorithm 148. 排序链表

[LeetCode] 148. 排序链表