算法打卡第五周

leetcode第1969题
题目描述：
在经典汉诺塔问题中，有 3 根柱子及 N 个不同大小的穿孔圆盘，盘子可以滑入任意一根柱子。一开始，所有盘子自上而下按升序依次套在第一根柱子上(即每一个盘子只能放在更大的盘子上面)。移动圆盘时受到以下限制:
(1) 每次只能移动一个盘子;
(2) 盘子只能从柱子顶端滑出移到下一根柱子;
(3) 盘子只能叠在比它大的盘子上。

请编写程序，用栈将所有盘子从第一根柱子移到最后一根柱子。

class Solution {
   public void hanota(List<Integer> A, List<Integer> B, List<Integer> C) {
        if (A==null || B == null || C == null) {
            return;
        }
        doMove(A.size(), A, B, C);
    }

    private void doMove(int len, List<Integer> origin, List<Integer> move, List<Integer> target) {
        if (len == 1) {
            target.add(origin.remove(origin.size()-1));
            return;
        }
        //1.将前len-1一个盘子借助于target柱子移动到中间柱子上
        doMove(len - 1, origin, target, move);
        //将第size个盘子移动到target柱子上
        target.add(origin.remove(origin.size() - 1));
        //将move上的len-1个盘子借助于origin柱子移动到target柱子上
        doMove(len - 1, move, origin, target);
    }
}

leetcode第148题
题目描述：
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
进阶：你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？

package leetcode;

import java.util.List;

/**
 * 已知链表的头结点   按照升序排列并返回排序后的链表
 *
 * @author jxy
 * @date 2021/4/8 16:44
 */
public class SortList {

    public static class ListNode {
        int val;
        ListNode next;

        ListNode() {
        }

        ListNode(int val) {
            this.val = val;
        }

        ListNode(int val, ListNode next) {
            this.val = val;
            this.next = next;
        }
    }

    public ListNode sortList(ListNode head) {
        return doSort(head);
    }

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

        //通过快慢指针查找中间指针
        ListNode node = new ListNode(0, head);
        ListNode fast = node, slow = node;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        ListNode mid = slow;
        //将mid.next以后的节点进行排序
        ListNode right = doSort(mid.next);
        mid.next = null;
        //head-mid的节点进行排序
        ListNode left = doSort(head);

        //合并
        return mergeSort(left, right);
    }

    public ListNode mergeSort(ListNode left, ListNode right) {
        ListNode head = new ListNode();
        ListNode cursor = head;
        while (left != null && right != null) {
            if (left.val <= right.val) {
                cursor.next = left;
                left = left.next;
            } else {
                cursor.next = right;
                right = right.next;
            }
            cursor = cursor.next;
        }
        if (left != null) {
            cursor.next = left;
        }
        if (right != null) {
            cursor.next = right;
        }
        return head.next;
    }

//    public void printAll(ListNode node) {
//        if (node == null) {
//            return;
//        }
//        while (node != null) {
//            System.out.print(node.val + "->");
//            node = node.next;
//        }
//    }
}