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

654.最大二叉树

public TreeNode constructMaximumBinaryTree(int[] nums) {
    return getMaxTree(nums,0,nums.length-1);
}

public TreeNode getMaxTree(int[] nums, int head, int tail) {
    if (head > tail) {
        return null;
    }
    int maxIndex = getMaxIndex(nums, head, tail);
    int rootValue = nums[maxIndex];
    TreeNode root = new TreeNode(rootValue);
    root.left = getMaxTree(nums, head, maxIndex - 1);
    root.right = getMaxTree(nums, maxIndex + 1, tail);
    return root;

}

public int getMaxIndex(int[] nums, int head, int tail) {
    int maxIndex = head;
    for (int i = head; i <=tail; i++) {
        if (nums[i] > nums[maxIndex]) {
            maxIndex = i;
        }
    }
    return maxIndex;
}

617.合并二叉树

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
    if (root1 == null && root2 != null) {
        return root2;
    }
    if (root2 == null && root1 != null) {
        return root1;
    }
    if (root2 == null && root1 == null) {
        return null;
    }
    TreeNode treeNode = new TreeNode();
    treeNode.val = root1.val + root2.val;

    TreeNode dfsLeft = mergeTrees(root1.left, root2.left);
    TreeNode dfsRight = mergeTrees(root1.right, root2.right);
    treeNode.left = dfsLeft;
    treeNode.right = dfsRight;

    return treeNode;
}

700.二叉搜索树中的搜索 

public TreeNode searchBST(TreeNode root, int val) {
    int[] value = {val};
    List<TreeNode> list = new ArrayList<>();
    List<Integer> ans = new ArrayList<>();
    search(root, value, list, ans);
    if (!ans.contains(val)) {
        return null;
    }
    if (list.isEmpty()) {
        return null;
    }
    return list.get(0);
}

public TreeNode search(TreeNode root, int[] val, List<TreeNode> list,
                       List<Integer> ans) {
    if (root == null) {
        return null;
    }
    if (root.val == val[0]) {
        list.add(root);
    }
    ans.add(root.val);
    TreeNode leftTreeNode = search(root.left, val, list, ans);
    TreeNode rightTreeNode = search(root.right, val, list, ans);
    root.left = leftTreeNode;
    root.right = rightTreeNode;

    return root;
}

98.验证二叉搜索树

public boolean isValidBST(TreeNode root) {
    return valid(root, Long.MAX_VALUE, Long.MIN_VALUE);

}

public Boolean valid(TreeNode root, Long maxVal, Long minVal) {
    if (root == null) {
        return true;
    }

    if (root.val <= minVal || root.val >= maxVal) {
        return false;
    }

    Boolean leftValid = valid(root.left, new Long(root.val), minVal);
    Boolean rightValid = valid(root.right, maxVal, new Long(root.val));

    return leftValid && rightValid;
}