有序链表转换二叉搜索树(树)、不同的二叉搜索树 II(树)、买卖股票的最佳时机 III(数组、动态规划)

原创

共饮一杯无 2023-05-11 14:46:31 博主文章分类：数据结构与算法 ©著作权

文章标签 二叉搜索树有序链表 java 文章分类 Java 后端开发 yyds干货盘点

©著作权归作者所有：来自51CTO博客作者共饮一杯无的原创作品，请联系作者获取转载授权，否则将追究法律责任

有序链表转换二叉搜索树(树)

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。本题中，一个高度平衡二叉树是指一个二叉树_每个节点 _的左右两个子树的高度差的绝对值不超过 1。 示例:

给定的有序链表： [-10, -3, 0, 5, 9], 
一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树： 
   0 
  / \ 
 -3  9 
 /   / 
-10  5

解答：

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;
    }
}
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode() {
    }
    TreeNode(int val) {
        this.val = val;
    }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}
class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if (head == null)
            return null;
        return helper(head, null);
    }
    private TreeNode helper(ListNode start, ListNode end) {
        if (start == end)
            return null;
        ListNode slow = start;
        ListNode fast = start;
        while (fast != end && fast.next != end) {
            slow = slow.next;
            fast = fast.next.next;
        }
        TreeNode root = new TreeNode(slow.val);
        root.left = helper(start, slow);
        root.right = helper(slow.next, end);
        return root;
    }
}

不同的二叉搜索树 II(树)

给你一个整数 n ，请你生成并返回所有由 n 个节点组成且节点值从 1 到 n 互不相同的不同 二叉搜索树_ _。可以按 任意顺序 返回答案。

示例 1： 输入：n = 3 输出：[[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]] 示例 2： 输入：n = 1 输出：[[1]]

提示：

1 <= n <= 8

解答：

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        val = x;
    }
}
class Solution {
    public List<TreeNode> generateTrees(int n) {
        if (n == 0)
            return new LinkedList<TreeNode>();
        return generate_trees(1, n);
    }
    private LinkedList<TreeNode> generate_trees(int start, int end) {
        LinkedList<TreeNode> all_trees = new LinkedList<TreeNode>();
        if (start > end) {
            all_trees.add(null);
            return all_trees;
        }
        for (int i = start; i <= end; i++) {
            LinkedList<TreeNode> left_trees = generate_trees(start, i - 1);
            LinkedList<TreeNode> right_trees = generate_trees(i + 1, end);
            for (TreeNode l : left_trees)
                for (TreeNode r : right_trees) {
                    TreeNode current_tree = new TreeNode(i);
                    current_tree.left = l;
                    current_tree.right = r;
                    all_trees.add(current_tree);
                }
        }
        return all_trees;
    }
}

买卖股票的最佳时机 III(数组、动态规划)

给定一个数组，它的第_ i 个元素是一支给定的股票在第 i _天的价格。设计一个算法来计算你所能获取的最大利润。你最多可以完成 **两笔 **交易。 **注意：**你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1: 输入：prices = [3,3,5,0,0,3,1,4] 输出：6 解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天（股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。 示例 2： 输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 示例 3： 输入：prices = [7,6,4,3,1] 输出：0 解释：在这个情况下, 没有交易完成, 所以最大利润为 0。 示例 4： 输入：prices = [1] 输出：0

提示：

1 <= prices.length <= 105
0 <= prices[i] <= 105

解答：

public class Solution {
    public int maxProfit(int[] prices) {
        int result = 0;
        if (prices.length == 0) {
            return result;
        }
        int firstDealSell;
        int secondDealSell;
        for (secondDealSell = prices.length - 1; secondDealSell > 0; secondDealSell--) {
            if (prices[secondDealSell - 1] < prices[secondDealSell]) {
                break;
            }
        }
        for (firstDealSell = 1; firstDealSell < prices.length; firstDealSell++) {
            while (firstDealSell + 1 < prices.length && prices[firstDealSell + 1] >= prices[firstDealSell]) {
                firstDealSell++;
            }
            int result1 = maxProfit(prices, 0, firstDealSell);
            int result2 = maxProfit(prices, firstDealSell + 1, secondDealSell);
            if (result1 + result2 > result) {
                result = result1 + result2;
            }
        }
        return result;
    }
    private int maxProfit(int[] prices, int left, int right) {
        int result = 0;
        if (right - left < 1) {
            return result;
        }
        int minPrice = prices[left];
        for (int i = left + 1; i <= right; i++) {
            result = Math.max(result, prices[i] - minPrice);
            minPrice = Math.min(minPrice, prices[i]);
        }
        return result;
    }
}