LeetCode 148. Sort List

最新推荐文章于 2025-05-22 22:16:20 发布

原创最新推荐文章于 2025-05-22 22:16:20 发布 · 239 阅读

0 ·

CC 4.0 BY-SA版权

LeetCode 专栏收录该内容

51 篇文章

订阅专栏

本文介绍了一种在O(nlogn)时间内使用常量空间复杂度对链表进行排序的方法，采用归并排序算法实现。文章详细解释了如何将链表一分为二，递归排序左右两边的链表，并最终合并两个有序链表。

问题描述

https://leetcode.com/problems/sort-list/description/
Sort a linked list in O(n log n) time using constant space complexity.
使用空间复杂度为常量，时间复杂度为 O（nlgn）对链表进行排序。

问题分析

排序的算法复杂度为O(nlgn)的有三种，快速排序，堆排序，归并排序。这里使用归并排序。
三步：
将当前链表一分为二，取得中间节点。其中需要注意的是，如果长度是奇数，中间那个节点在左边。
对左边和右边的链表进行排序。
归并两个有序链表。

算法实现

/**
     * 使用常数空间
     * 和O(nlgn)的时间复制度来对链表进行排序
     * 归并排序
     * 先逐步的将节点进行  两两排序。然后合并，最后到所有的排序。
     * 归并排序：见过一个数组分为两部；对这两部分分别排序；归并排好序的数组。
     * 0,21,15,
     * 24,3,13
     *
     * @param head
     * @return
     */
    public ListNode sortList(ListNode head) {


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

        ListNode leftHead = head;
        ListNode rightHead = getMiddle(head);

        leftHead = sortList(leftHead);
        rightHead = sortList(rightHead);
        return merge(leftHead, rightHead);

    }

    /**
     * 将两个量表合并在一起，以leftHead为头部
     *
     * @param leftHead
     * @param rightHead
     */
    protected ListNode merge(ListNode leftHead, ListNode rightHead) {


        ListNode head = new ListNode(0);
        ListNode helper = head;
        ListNode leftPoint = leftHead;
        ListNode rightPoint = rightHead;
        ListNode temp = null;

        while (leftPoint != null && rightPoint != null) {
            if (leftPoint.val < rightPoint.val) {
                temp = leftPoint;
                leftPoint = leftPoint.next;
            } else {
                temp = rightPoint;
                rightPoint = rightPoint.next;
            }
            helper.next = temp;
            helper = temp;
        }

        if (leftPoint != null) {
            helper.next = leftPoint;
        }
        if (rightPoint != null) {
            helper.next = rightPoint;
        }
        return head.next;
    }

    /**
     * 返回一个链表的中间节点.同时需要将两个数组给阶段开来
     * <p>
     * 如果奇数，前面的数需要多放置一个，后面的节点数要少
     *
     * @param head
     * @return
     */
    protected ListNode getMiddle(ListNode head) {

        if (head == null) {
            return null;
        }

        ListNode fast = head.next;
        ListNode slow = head.next;
        ListNode pre = head;
        while (true) {
            if (fast != null) {
                fast = fast.next;
            } else {
                break;
            }
            if (fast != null) {
                fast = fast.next;
            } else {
                break;
            }
            pre = slow;
            slow = slow.next;
        }
        pre.next = null;
        return slow;
    }