牛客網高頻演算法題系列-BM12-單連結串列的排序

雄獅虎豹發表於2022-06-11
演算法排序

牛客網高頻演算法題系列-BM12-單連結串列的排序

題目描述

描述

原題目見：BM12 單連結串列的排序

解法一：陣列排序

首先判斷如果連結串列為空或者只有一個結點，則不需要排序，直接返回原連結串列。

否則，使用額外空間進行排序，處理過程如下：

  • 首先遍歷連結串列，將所有結點值暫存在一個List中；
  • 然後，使用庫函式將List排序（也可以使用各種排序演算法進行排序）；
  • 最後，將排序後的結點值構造成新的連結串列並返回。

解法二：歸併排序

使用遞迴的方式，將原連結串列排序，遞迴處理過程如下：

  • 首先也是要判斷如果連結串列為空或者只有一個結點，則不需要處理，直接返回原連結串列；
  • 然後，使用快慢指標尋找連結串列的中點位置；
  • 然後，遞迴呼叫分別排序中點左右的兩個連結串列；
  • 然後，將左右連結串列合併；
  • 最後，返回合併後的連結串列。

程式碼

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Bm012 {
    /**
     * 陣列排序
     *
     * @param head ListNode類 the head node
     * @return ListNode類
     */
    public static ListNode sortInList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        List<Integer> nodes = new ArrayList<>();
        while (head != null) {
            nodes.add(head.val);
            head = head.next;
        }
        // 使用庫函式將陣列排序
        Collections.sort(nodes);
        ListNode newHead = new ListNode(-1);
        ListNode cur = newHead;
        for (Integer val : nodes) {
            cur.next = new ListNode(val);
            cur = cur.next;
        }
        return newHead.next;
    }

    /**
     * 歸併排序
     *
     * @param head ListNode類 the head node
     * @return ListNode類
     */
    public static ListNode sortInList2(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        // 使用快慢指標尋找連結串列的中點位置
        ListNode fast = head.next, slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        ListNode tmp = slow.next;
        slow.next = null;
        // 遞迴左右兩邊進行排序
        ListNode left = sortInList(head);
        ListNode right = sortInList(tmp);
        // 建立新的連結串列
        ListNode newHead = new ListNode(-1);
        ListNode cur = newHead;
        // 合併left和right連結串列
        while (left != null && right != null) {
            if (left.val < right.val) {
                cur.next = left;
                left = left.next;
            } else {
                cur.next = right;
                right = right.next;
            }
            cur = cur.next;
        }
        cur.next = left != null ? left : right;

        return newHead.next;
    }

    public static void main(String[] args) {
        ListNode head = ListNode.testCase5();
        System.out.println("原連結串列");
        ListNode.print(head);

        System.out.println("排序後的連結串列");
        ListNode.print(sortInList(head));
        ListNode.print(sortInList2(head));
    }
}
$1.01^{365} ≈ 37.7834343329$
$0.99^{365} ≈ 0.02551796445$
相信堅持的力量！

相關文章