代码随想录算法训练营|DAY20|二叉树|654.最大二叉树、 617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

654.最大二叉树

代码随想录讲解链接

思路

• 构造二叉树
• 前序遍历
• 递归三要素

代码

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return constructMaximumBinaryTree1(nums, 0, nums.length);
    }

    public TreeNode constructMaximumBinaryTree1(int[] nums, int leftIndex, int rightIndex) {
        if (rightIndex - leftIndex < 1) {
            return null;
        }
        if (rightIndex - leftIndex == 1) {
            return new TreeNode(nums[leftIndex]);
        }
        int maxIndex = leftIndex;// 最大值所在位置
        int maxVal = nums[maxIndex];// 最大值
        for (int i = leftIndex + 1; i < rightIndex; i++) {
            if (nums[i] > maxVal){
                maxVal = nums[i];
                maxIndex = i;
            }
        }
        TreeNode root = new TreeNode(maxVal);
        // 根据maxIndex划分左右子树
        root.left = constructMaximumBinaryTree1(nums, leftIndex, maxIndex);
        root.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);
        return root;
    }
}

617.合并二叉树

代码随想录讲解链接

思路

• 迭代法中，一般一起操作两个树都是使用队列模拟类似层序遍历，同时处理两个树的节点

代码

class Solution {
    // 使用队列迭代
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) return root2;
        if (root2 ==null) return root1;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root1);
        queue.offer(root2);
        while (!queue.isEmpty()) {
            TreeNode node1 = queue.poll();
            TreeNode node2 = queue.poll();
            // 此时两个节点一定不为空，val相加
            node1.val = node1.val + node2.val;
            // 如果两棵树左节点都不为空，加入队列
            if (node1.left != null && node2.left != null) {
                queue.offer(node1.left);
                queue.offer(node2.left);
            }
            // 如果两棵树右节点都不为空，加入队列
            if (node1.right != null && node2.right != null) {
                queue.offer(node1.right);
                queue.offer(node2.right);
            }
            // 若node1的左节点为空，直接赋值
            if (node1.left == null && node2.left != null) {
                node1.left = node2.left;
            }
            // 若node1的右节点为空，直接赋值
            if (node1.right == null && node2.right != null) {
                node1.right = node2.right;
            }
        }
        return root1;
    }
}

700.二叉搜索树中的搜索

代码随想录讲解链接

思路

• 递归三部曲

代码

class Solution {
    // 递归，普通二叉树
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        TreeNode left = searchBST(root.left, val);
        if (left != null) {
            return left;
        }
        return searchBST(root.right, val);
    }
}

98.验证二叉搜索树

代码随想录讲解链接

思路

• 遇到 搜索树，一定想着中序遍历，这样才能利用上特性
• 中序遍历下，输出的二叉搜索树节点的数值是有序序列
• 验证二叉搜索树，就相当于变成了判断一个序列是不是递增
• 陷阱1
  不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了
• 陷阱2
  样例中最小节点 可能是int的最小值，如果这样使用最小的int来比较也是不行的

代码

class Solution {
    public boolean isValidBST(TreeNode root) {
        if (root == null) {
            return true;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;// 左
            }
            // 中，处理
            TreeNode pop = stack.pop();
            if (pre != null && pop.val <= pre.val) {
                return false;
            }
            pre = pop;

            root = pop.right;// 右
        }
        return true;
    }
}

剑指Offer58-II.左旋转字符串

代码随想录讲解链接

思路

• 局部反转+整体反转
• 具体步骤为：
  • 反转区间为前n的子串
  • 反转区间为n到末尾的子串
  • 反转整个字符串

代码

class Solution {
    public String reverseLeftWords(String s, int n) {
        StringBuilder sb = new StringBuilder(s); 
        reverse(sb, 0, n - 1);
        reverse(sb, n, sb.length() - 1);
        reverse(sb, 0, sb.length() - 1);//注意这个最后
        return sb.toString();
    }
    private void reverse(StringBuilder sb, int start, int end){
        while(end > start){
            char tmp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));

            sb.setCharAt(end, tmp);
            start++;
            end--;
        }
        
    }
}

    
    private void reverseWord (StringBuilder sb){
        int start = 0;
        int end = 1;
        int n = sb.length();

        while (start < n) {
            while (end < n && sb.charAt(end) != ' ') {
                end++;
            }
            reverseString(sb, start, end - 1);
            start = end + 1;
            end = start + 1;
        }
    }
}