从0到1算法之类路途漫漫 Day 16 二叉树part 05-CSDN博客

本文链接：https://blog.csdn.net/wxgcsky/article/details/148498916

Day 16 二叉树part 05

654. 最大二叉树

我们知道：在所给定的区间内做操作即可

问题

左右区间该如何划分根据maxIndex来划分数组区间，传入老数组，但是区间下标改变（左闭右开），省了几个步骤
直接传入分割后的数组即可，并且返回给左或右子树，就会自动拼接 return node；上面的node.left和node.right 都是被构建完了，和node一起返回回去
我们传入老数组，左右下标不限制可用数组大小是否大于等于1，没有元素了，我们仍然需要判断，返回null；数组还剩一个元素我们就直接构造节点返回，否则就继续分数组，找最大值，构造树。 return new TreeNode(nums[leftIndex]);//左闭右开只有左是实际的，而右是虚的

int maxIndex = leftIndex;
int maxValue = nums[maxIndex];//这里填写maxIndex,不写leftIndex，这样可读，也保证更改只修改一次

for (int i = leftIndex + 1; i < rightIndex; i++) {//1.犯了大忌，下标不是固定从1开始的,而是从leftIndex+1;因为左区间下标不是固定不变的，也是因为默认值为leftIndex指向的数组下标，所有从下一个开始判断   2.终止条件是小于rightIndex而不是nums.length   注意！！！我们是在传入的本区间进行判断操作
    if (nums[i] > maxValue) {
        maxValue = nums[i];//找出最大值
        maxIndex = i;//找出最大值数组
    }
}

根据maxIndex来划分数组区间，传入老数组，但是区间下标改变（左闭右开），省了几个步骤

node.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);

原先写的是nums.length，这样不妥

形参是rightIndex会接收传入的nums.length，最大值右区间时，保持不变
左区间时，会根据最大值下标改变rightIndex

node.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);

这里结束是写rightIndex还是写rightIndex-1，我们就看透本质，最基础（第一次）的是如何，1.第一次传入nums.length，2.包左不包右，如果我-1就不妥了,所以是rightIndex

我们递归很多时候就只用判断第一层即可

public class Maximum_Binary_Tree {
    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 maxValue = nums[maxIndex];//这里填写maxIndex,不写leftIndex
        for (int i = leftIndex + 1; i < rightIndex; i++) {//犯了大忌，下标不是固定从1开始的,而是从leftIndex+1，也是因为，默认值为leftIndex指向的数组下标，所有从下一个开始判断2.终止条件是小于rightIndex而不是nums.length
            if (nums[i] > maxValue) {
                maxValue = nums[i];//找出最大值
                maxIndex = i;//找出最大值数组
            }
        }
        TreeNode node = new TreeNode(maxValue);
        //根据maxIndex来划分数组区间，传入老数组，但是区间下标改变（左闭右开），省了几个步骤
        node.left = constructMaximumBinaryTree1(nums, leftIndex, maxIndex);
        node.right = constructMaximumBinaryTree1(nums, maxIndex + 1, rightIndex);//原先写的是nums.length，这样不妥 1.接收元素是rightIndex 所以右下标会继承nums.length，2.左区间会根据变量改变右下标
        return node; //上面的node.left和node.right 都是构建完了，和node一起返回的
    }
}

617. 合并二叉树

递归的顿悟：我们很多时候单单只根据第一层的行径逻辑，再加上特殊情况、终止条件的开始判断，就可以写出递归的正确逻辑。我们只需要以第一层为蓝本就行

同时遍历两棵树，

方法1 是合并的写法

就像这道题，我们那t1作为返回的树，直接在上面操作。t1为空，我们就替补t2；t2为空，我们就替换原本的t1. 假设两个都为空，我们这里的意思也就是返回空了。两个都不为空，我们就让两个相加。

两个数的遍历都是同时进行的，遍历左、右节点，传入左右子树t1.left,t2.left

    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) return root2; // 如果t1为空，合并之后就应该是t2
        if (root2 == null) return root1;//    如果t2为空，合并之后就应该是t1若root1==null，则就返回null了
        root1.val += root2.val;
        root1.left = mergeTrees(root1.left, root2.left);
        root1.right = mergeTrees(root1.right, root2.right);
        return root1;
    }

方法二

当然也可以定义一个新的二叉树，不改变原来两树的结构

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {		//为空另外一棵树就直接替代
        if (root1 == null) return root2;
        if (root2 == null) return root1;
        TreeNode node = new TreeNode(0); //创建新节点
        node.val = root1.val + root2.val;
        node.left = mergeTrees(root1.left, root2.left);
        node.right = mergeTrees(root1.right, root2.right);
        return node;
}

700. 二叉搜索树中的搜索

搜索树

以下的这个代码是错误的，是我的第一想法

public TreeNode searchBST(TreeNode root, int val) {
        if (root.val == val) return root;
        if (root.val != val && root.left == null && root.right == null) return null;
        if (val < root.val && root.left != null) searchBST(root.left, val);
        if (val > root.val && root.right != null) searchBST(root.right, val);
        return root;//不知道返回什么好  因为编译器强制报红了
    }

不知道返回什么好因为编译器强制报红了，返回过来的searchBST（）必须用一个变量来接住。

正确

搜索树解法

法1

以下代码很精妙，root=null也返回root，因为root为空，正好就返回null

if (root == null || root.val == val) {
            return root;
        }

这里看似没有判断左右子树是否为空，也没有判断是否到了叶子节点，其实都藏在root==null的判断当中了

public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        if (val < root.val) {
            return searchBST(root.left, val);
        } else {
            return searchBST(root.right, val);
        }
    }

左右向下遍历总要遇到null返回null的，不用太担心

法2

public TreeNode searchBST(TreeNode root, int val) {
        if (root == null || root.val == val) {
            return root;
        }
        TreeNode result = null;
        if (root.val > val) {
            result = searchBST(root.left, val);
        } else {
            result = searchBST(root.right, val);
        }
        return result;//找不到就是null了
    }

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

普通树的解法

 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. 验证二叉搜索树

注意二叉搜索树，中节点是必然大于左子树上的所有节点，小于大于右子树上的所有节点注意是不包含等于的，加上等于就不是二叉搜索树了

错误代码

 if (root.left != null & root.val < root.left.val) return false;
        if (root.right != null & root.val > root.right.val) return false;
        if (root.left != null && root.right != null && root.right.val > root.left.val) return true;
        return isValidBST(root.left) && isValidBST(root.right);

思路

二叉搜索树中序遍历出来是一个有序是数组（可以使用集合来组装）

单单中节点比左节点大，比右节点小，还不是二叉搜索树。二叉搜索树是中节点比右子树的所有节点都要小，比左子树所有节点都要大。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

新增一个变量进行比较，大就赋值，小就返回false
直接对前一个和后一个节点进行比较

if (root == null) return; //这条判断必须加，否则就操作空指针

方法一判断

 private List<Integer> result = new ArrayList<>();

    public void traversal(TreeNode root) {
        if (root == null) return; //这条判断必须加，否则就操作空指针
        traversal(root.left);
        result.add(root.val);
        traversal(root.right);
    }

    public boolean isValidBST(TreeNode root) {
        traversal(root);//这个也必须加
        //判断是否有序
        for (int i = 0; i < result.size() - 1; i++) {
            if (result.get(i) >= result.get(i + 1)) {
                return false;
            }
        }
        return true;
    }

方法二

private long preValue = Long.MIN_VALUE;//需要一个全局变量

    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        boolean left = isValidBST(root.left);
        if (preValue >= root.val) { //需要加=？
            return false;
        }
        preValue = root.val;
        boolean right = isValidBST(root.right);
        return left && right;
    }

方法三

  private TreeNode pre  = null;//需要一个全局变量  必须初始化为null

    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        boolean left = isValidBST(root.left);
     //   pre = null; 这里不能重置为null，否则前面存储的都白费了
        if (pre != null && pre.val >= root.val) { //需要加=？
            return false;
        }
        pre = root;
        boolean right = isValidBST(root.right);
        return left && right;
    }

当时我在考虑 private TreeNode pre = null;l这里的初始化会不会影响后面的递归？只是执行一次吗，还是每次递归都是会执行？

答案是仅执行一次

而我这里的pre=null 每次初始化都会被重复执行——重置

优化递归，提早终止递归的方法

 private TreeNode pre = null;//需要一个全局变量  必须初始化为null

    public boolean isValidBST(TreeNode root) {
        if (root == null) return true;
        boolean left = isValidBST(root.left);// 左子树非法则提前终止
        if (!left) return false;
        //   pre = null; 这里不能重置为null，否则前面存储的都白费了
        if (pre != null && pre.val >= root.val) { //需要加=？
            return false;
        }
        pre = root;
        boolean right = isValidBST(root.right);
        return right; //能通过上面的，说明left是为true，所有这里只要返回right即可
    }