代码随想录训练第十五天|LeetCode654.最大二叉树、LeetCode617.合并二叉树、LeetCode700.二叉搜索树中的搜索、LeetCode98.验证二叉搜索树

文章目录

654.最大二叉树
- 思路
**617.合并二叉树**
700.二叉搜索树中的搜索
98.验证二叉搜索树

654.最大二叉树

给定一个不重复的整数数组 nums 。 最大二叉树 可以用下面的算法从 nums 递归地构建:

创建一个根节点，其值为 nums 中的最大值。
递归地在最大值左边的 子数组前缀上 构建左子树。
递归地在最大值右边的 子数组后缀上 构建右子树。

返回 nums 构建的 *最大二叉树* 。

示例 1：

输入：nums = [3,2,1,6,0,5]
输出：[6,3,5,null,2,0,null,null,1]
解释：递归调用如下所示：
- [3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5] 。
    - [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1] 。
        - 空数组，无子节点。
        - [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1] 。
            - 空数组，无子节点。
            - 只有一个元素，所以子节点是一个值为 1 的节点。
    - [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 [] 。
        - 只有一个元素，所以子节点是一个值为 0 的节点。
        - 空数组，无子节点。

示例 2：

输入：nums = [3,2,1]
输出：[3,null,2,null,1]

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000
nums 中的所有整数 互不相同

Related Topics

栈
树
数组
分治
二叉树
单调栈

思路

最大二叉树的构建过程如下：

654.最大二叉树

构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。

确定递归函数的参数和返回值

参数传入的是存放元素的数组，返回该数组构造的二叉树的头结点，返回类型是该节点。

由于java数组无法改变大小,所以采用左右下标加上总数组代表一段数组

public TreeNode travel(int[] nums,int begin,int end){
    
}

确定终止条件

题目中说了输入的数组大小一定是大于等于1的，所以我们不用考虑小于1的情况，那么当递归遍历的时候，如果传入的数组大小为1，说明遍历到了叶子节点了。

那么应该定义一个新的节点，并把这个数组的数值赋给新的节点，然后返回这个节点。这表示一个数组大小是1的时候，构造了一个新的节点，并返回。

代码如下：

		//递归出口
		//已经没有元素了
		if(end-begin<1) {
			return null;
		}
		if(end-begin==1) {
			return new TreeNode(nums[begin]);
		}

确定单层递归的逻辑

这里有三步工作

先要找到数组中最大的值和对应的下标，最大的值构造根节点，下标用来下一步分割数组。

代码如下：

		//找到最大值所在位置
		int maxIndex = begin;
		int maxVal = nums[maxIndex];
		for (int i = begin; i < end; i++) {
			if(nums[i]>maxVal)
			{
				maxIndex = i;
				maxVal = nums[maxIndex];
			}
		}

最大值所在的下标左区间构造左子树

代码如下：

		//设置当前节点
		TreeNode temp = new TreeNode(maxVal);
		//向左子树遍历添加
		temp.left = travel(nums,begin,maxIndex);

最大值所在的下标右区间构造右子树

		//向右子树遍历添加
		temp.right = travel(nums,maxIndex+1,end);

最后返回当前节点

		return temp;

整体代码

	public TreeNode constructMaximumBinaryTree(int[] nums) {
		//遵从左闭又开
		 TreeNode res=travel(nums,0,nums.length);
		return res;
    }

	/**
	 * @Description 递归创造最大数组
	 * @Param nums
	 * @Param begin 左闭
	 * @Param end 右开
	 * @Return {@link TreeNode} 由于需要返回一个头节点
	 * @Author 君君
	 * @Date 2024/7/8 18:40
	 */
	public TreeNode travel(int[] nums,int begin,int end) {
		//递归出口
		//以及没有元素了
		if(end-begin<1) {
			return null;
		}
		if(end-begin==1) {
			return new TreeNode(nums[begin]);
		}
		//找到最大值所在位置
		int maxIndex = begin;
		int maxVal = nums[maxIndex];
		for (int i = begin; i < end; i++) {
			if(nums[i]>maxVal)
			{
				maxIndex = i;
				maxVal = nums[maxIndex];
			}
		}
		//设置当前节点
		TreeNode temp = new TreeNode(maxVal);
        //其实在这里应该有空节点的判断,但是,本代码将空间节点的判断留在了下一次递归递归中,在下一次递归中返回空节点就可以.
		//向左子树遍历添加
		temp.left = travel(nums,begin,maxIndex);
		//向右子树遍历添加
		temp.right = travel(nums,maxIndex+1,end);
		return temp;
	}

时间复杂度O(n)

空间复杂度O(n)

617.合并二叉树

给你两棵二叉树： root1 和 root2 。

想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。

返回合并后的二叉树。

注意: 合并过程必须从两个树的根节点开始。

示例 1：

输入：root1 = [1,3,2,5], root2 = [2,1,3,null,4,null,7]
输出：[3,4,5,5,4,null,7]

示例 2：

输入：root1 = [1], root2 = [1,2]
输出：[2,2]

提示：

两棵树中的节点数目在范围 [0, 2000] 内
-104 <= Node.val <= 104

Related Topics

树
深度优先搜索
广度优先搜索
二叉树

思路

相信这道题目很多同学疑惑的点是如何同时遍历两个二叉树呢？

其实和遍历一个树逻辑是一样的，只不过传入两个树的节点，同时操作。

递归法

二叉树使用递归，就要想使用前中后哪种遍历方式？

本题使用哪种遍历都是可以的！

我们下面以前序遍历为例。

动画如下：

617.合并二叉树

那么我们来按照递归三部曲来解决：

确定递归函数的参数和返回值：

首先要合入两个二叉树，那么参数至少是要传入两个二叉树的根节点，返回值就是合并之后二叉树的根节点。

代码如下：

	private TreeNode travel(TreeNode root1, TreeNode root2) {
		...
	}

确定终止条件：

		if(root1==null&&root2==null)
		{
			return null;
		}
		if (root1!=null&&root2==null)
		{
			return root1;
		}
		if (root1==null&&root2!=null)
		{
			return root2;
		}

因为是传入了两个树，那么就有两个树遍历的节点root1和 root2，如果root1== NULL 了，两个树合并就应该是 root2了（如果root2也为NULL也无所谓，合并之后就是NULL）。

反过来如果root2== NULL，那么两个数合并就是root1（如果root1也为NULL也无所谓，合并之后就是NULL）。

代码如下：

if (root1 == null) return root2; // 如果t1为空，合并之后就应该是t2
if (root2 == null) return root1; // 如果t2为空，合并之后就应该是t1

确定单层递归的逻辑：

单层递归的逻辑就比较好写了，这里我们重复利用一下t1这个树，t1就是合并之后树的根节点（就是修改了原来树的结构）。

那么单层递归中，就要把两棵树的元素加到一起。

root1.val += root2.val;
//向左右子树进行遍历
root1.left = travel(root1.left,root2.left);
root1.right = travel(root1.right,root2.right);
//最终返回二叉树1的节点.
return root1;

整体代码

    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
		return travel(root1,root2);
    }

	/**
	 * @Description 递归法(前序遍历),直接在二叉树1上进行改变
	 * @Param root1 二叉树1
	 * @Param root2 二叉树2
	 * @Return {@link leetcode.editor.util.TreeNode}
	 * @Author 君君
	 * @Date 2024/7/8 19:30
	 */
	private TreeNode travel(TreeNode root1, TreeNode root2) {
		//if(root1==null&&root2==null)
		//{
		//	return null;
		//}
		//if (root1!=null&&root2==null)
		//{
		//	return root1;
		//}
		//if (root1==null&&root2!=null)
		//{
		//	return root2;
		//}
		if (root1 == null) return root2; // 如果t1为空，合并之后就应该是t2
		if (root2 == null) return root1; // 如果t2为空，合并之后就应该是t1
		root1.val+=root2.val;
		root1.left = travel(root1.left,root2.left);
		root1.right = travel(root1.right,root2.right);
		//最终返回二叉树1的节点.
		return root1;
	}

迭代法

使用迭代法，如何同时处理两棵树呢？

思路我们在二叉树：我对称么？ (opens new window)中的迭代法已经讲过一次了，求二叉树对称的时候就是把两个树的节点同时加入队列进行比较。

本题我们也使用队列，模拟的层序遍历，代码如下：

/**
 * @Description 迭代法(层序遍历)
 * @Param root1
 * @Param root2
 * @Return {@link TreeNode}
 * @Author 君君
 * @Date 2024/7/8 22:25
 */
public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
    if (root1 == null) return root2;
    if (root2 == null) return root1;
    //分别存储两个二叉树,这种方法无法实现需求,主要是两个二叉树节点数量,以及节点位置不一定相等
    //Deque<TreeNode> deque1 = new LinkedList<>();
    //Deque<TreeNode> deque2 = new LinkedList<>();
    //deque1.offer(root1);
    //deque1.offer(root2);
    //TreeNode res = new TreeNode(root1.);
    Deque<TreeNode> deque = new LinkedList<>();
    deque.offer(root1);
    deque.offer(root2);
    while (!deque.isEmpty()) {
        //取出当前节点
        TreeNode temp1 = deque.poll();
        TreeNode temp2 = deque.poll();
        //在加下来的遍历中已经确定队列内的节点不会为空值
        temp1.val = temp1.val + temp2.val;
        //左
        if (temp1.left != null && temp2.left != null) {
            deque.offer(temp1.left);
            deque.offer(temp2.left);
        }
        //右
        if (temp1.right != null && temp2.right != null) {
            deque.offer(temp1.right);
            deque.offer(temp2.right);
        }

        //如果temp1的左右节点为空,但是temp2的左右节点不为空,
        //则将temp2的节点值赋给temp1的左右节点
        //因为使用temp1作为结果二叉树,所以不需要判断temp1左右节点不为空,temp2左右节点为空的情况
        if (temp1.left == null && temp2.left != null) {
            temp1.left = temp2.left;
        }
        if (temp1.right == null && temp2.right != null) {
            temp1.right = temp2.right;
        }
    }
    return root1;
}

时间复杂度O(n)

空间复杂度O(n+m)

700.二叉搜索树中的搜索

给定二叉搜索树（BST）的根节点 root 和一个整数值 val。

你需要在 BST 中找到节点值等于 val 的节点。返回以该节点为根的子树。如果节点不存在，则返回 null 。

示例 1:

输入：root = [4,2,7,1,3], val = 2
输出：[2,1,3]

示例 2:

输入：root = [4,2,7,1,3], val = 5
输出：[]

提示：

树中节点数在 [1, 5000] 范围内
1 <= Node.val <= 107
root 是二叉搜索树
1 <= val <= 107

Related Topics

树
二叉搜索树
二叉树

思路

之前我们讲的都是普通二叉树，那么接下来看看二叉搜索树。

在关于二叉树，你该了解这些！ (opens new window)中，我们已经讲过了二叉搜索树。

二叉搜索树是一个有序树：

若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉搜索树

这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。

本题，其实就是在二叉搜索树中搜索一个节点。那么我们来看看应该如何遍历。

递归法

确定递归函数的参数和返回值

递归函数的参数传入的就是根节点和要搜索的数值，返回的就是以这个搜索数值所在的节点。

代码如下：

	/**
	 * @Description 当前节点,目标值
	 * @Param root
	 * @Param val
	 * @Return {@link TreeNode}
	 * @Author 君君
	 * @Date 2024/7/8 23:08
	 */
private TreeNode search(TreeNode root,int val){
    
}

确定终止条件

如果root为空，或者找到这个数值了，就返回root节点。

		//没找到目标节点,返回null
		if(root==null) {
			return null;
		}	
		//找到了目标节点,返回root
		if (root.val==val) {
			return root;
		}

确定单层递归的逻辑

看看二叉搜索树的单层递归逻辑有何不同。

因为二叉搜索树的节点是有序的，所以可以有方向的去搜索。

如果root->val > val，搜索左子树，如果root->val < val，就搜索右子树，最后如果都没有搜索到，就返回NULL。

		//如果root.val>val 则在左子树中继续寻找
		else if (root.val>val) {
			return search(root.left,val);
		}
		//如果root.val<val 则在右子树中继续寻找
		else{
			return search(root.right,val);
		}

很多录友写递归函数的时候习惯直接写 search(root->left, val)，却忘了递归函数还有返回值。

递归函数的返回值是什么? 是左子树如果搜索到了val，要将该节点返回。如果不用一个变量将其接住，那么返回值不就没了。

所以要 result = search(root->left, val)。

整体代码

    public TreeNode searchBST(TreeNode root, int val) {
		return search(root,val);
    }

	/**
	 * @Description 当前节点,目标值
	 * @Param root
	 * @Param val
	 * @Return {@link TreeNode}
	 * @Author 君君
	 * @Date 2024/7/8 23:08
	 */
	private TreeNode search(TreeNode root,int val) {
		//没找到目标节点,返回null
		if(root==null) {
			return null;
		}	
		//找到了目标节点,返回root
		if (root.val==val) {
			return root;
		}
		//如果root.val>val 则在左子树中继续寻找
		else if (root.val>val) {
			return search(root.left,val);
		}
		//如果root.val<val 则在右子树中继续寻找
		else{
			return search(root.right,val);
		}
	}

时间复杂度O(h) h为数的高度

空间复杂度O(h)

迭代法

一提到二叉树遍历的迭代法，可能立刻想起使用栈来模拟深度遍历，使用队列来模拟广度遍历。

对于二叉搜索树可就不一样了，因为二叉搜索树的特殊性，也就是节点的有序性，可以不使用辅助栈或者队列就可以写出迭代法。

对于一般二叉树，递归过程中还有回溯的过程，例如走一个左方向的分支走到头了，那么要调头，在走右分支。

而对于二叉搜索树，不需要回溯的过程，因为节点的有序性就帮我们确定了搜索的方向。

例如要搜索元素为3的节点，我们不需要搜索其他节点，也不需要做回溯，查找的路径已经规划好了。

中间节点如果大于3就向左走，如果小于3就向右走，如图：

二叉搜索树

所以迭代法代码如下：

/**
 * @Description 迭代法
 * @Param root
 * @Param val
 * @Return {@link TreeNode}
 * @Author 君君
 * @Date 2024/7/8 23:18
 */
public TreeNode searchBST(TreeNode root, int val) {
    while (root != null) {
        if (root != null) {
            if (root.val == val) {
                return root;
            }
            //如果root.val>val 则在左子树中继续寻找
            else if (root.val > val) {
                root = root.left;
            }
            //如果root.val<val 则在右子树中继续寻找
            else {
                root = root.right;
            }
        }
    }
    return null;
}

时间复杂度O(h)

空间复杂度O(1)

98.验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下：

节点的左子树只包含小于当前节点的数。
节点的右子树只包含大于当前节点的数。
所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

输入：root = [2,1,3]
输出：true

示例 2：

输入：root = [5,1,4,null,null,3,6]
输出：false
解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：

树中节点数目范围在[1, 104] 内
-231 <= Node.val <= 231 - 1

Related Topics

树

深度优先搜索

二叉搜索树

二叉树

思路

要知道中序遍历下，输出的二叉搜索树节点的数值是有序序列。

有了这个特性，验证二叉搜索树，就相当于变成了判断一个序列是不是递增的了。

递归法

可以递归中序遍历将二叉搜索树转变成一个数组，代码如下：

然后只要比较一下，这个数组是否是有序的，注意二叉搜索树中不能有重复元素。

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

        public boolean isValidBST(TreeNode root) {
			//遍历二叉树,填充二叉树中序遍历数组
			travel( root);
			//判断二叉树是否为递增序列
			for (int i = 1; i < res.size(); i++) {
				if(res.get(i)<=res.get(i-1))
				{
					return false;
				}
			}
			return true;
        }

        private void travel(TreeNode root) {
            if (root == null) {
                return;
            }
            //中序遍历:左中右
            travel(root.left);
			res.add(root.val);
			travel(root.right);
        }

时间复杂度O(N)

空间复杂度O(N)

以上代码中，我们把二叉树转变为数组来判断，是最直观的，但其实不用转变成数组，可以在递归遍历的过程中直接判断是否有序。

这道题目比较容易陷入两个陷阱：

陷阱1

不能单纯的比较左节点小于中间节点，右节点大于中间节点就完事了。

写出了类似这样的代码：

if (root.val > root.left.val && root.val < root.right.val) {
    return true;
} else {
    return false;
}

我们要比较的是左子树所有节点小于中间节点，右子树所有节点大于中间节点。所以以上代码的判断逻辑是错误的。

例如： [10,5,15,null,null,6,20] 这个case：

二叉搜索树

节点10大于左节点5，小于右节点15，但右子树里出现了一个6 这就不符合了！

注意递归函数要有bool类型的返回值，我们在二叉树：递归函数究竟什么时候需要返回值，什么时候不要返回值？ (opens new window)中讲了，只有寻找某一条边（或者一个节点）的时候，递归函数会有bool类型的返回值。

其实本题是同样的道理，我们在寻找一个不符合条件的节点，如果没有找到这个节点就遍历了整个树，如果找到不符合的节点了，立刻返回。

确定终止条件

如果是空节点是不是二叉搜索树呢？

是的，二叉搜索树也可以为空！

代码如下：

	if (root == null) {
        return true;
    }

确定单层递归的逻辑

中序遍历，一直更新maxVal，一旦发现maxVal >= root.val，就返回false，注意元素相同时候也要返回false。

//中序遍历:左中右
    boolean left = travel(root.left);

    // 中序遍历，验证遍历的元素是不是从小到大
    //当遍历到最左子树的最左节点的时候当前值maxValue==null,所以要去除这种情况
    if (maxValue!=null&&root.val <= maxValue.val) {
        return false;
    } else {
        maxValue = root;
    }

    boolean right = travel(root.right);
    return left && right;

完整代码

//由于node.val定义范围很广,如果使用int 来记录当前最大value值,则会出现bug,
//所以直接使用节点来代表当前最大节点
private TreeNode maxValue;

public boolean isValidBST(TreeNode root) {
    //if(root.left==null&&root.right==null)
    //{
    //    return true;
    //}
    return travel(root);
}

private boolean travel(TreeNode root) {
    if (root == null) {
        return true;
    }
    //maxValue = root.val;

    //中序遍历:左中右
    boolean left = travel(root.left);

    // 中序遍历，验证遍历的元素是不是从小到大
    //当遍历到最左子树的最左节点的时候当前值maxValue==null,所以要去除这种情况
    if (maxValue!=null&&root.val <= maxValue.val) {
        return false;
    } else {
        maxValue = root;
    }

    boolean right = travel(root.right);
    return left && right;
}

时间复杂度O(N)

空间复杂度O(N)

迭代法

使用栈存储节点,实现中序遍历

/**
 * @Description 迭代法 中序遍历
 * @Param root
 * @Return {@link boolean}
 * @Author 君君
 * @Date 2024/7/9 0:59
 */
public boolean isValidBST(TreeNode root) {
    if (root == null) {
        return true;
    }
    Stack<TreeNode> stack = new Stack<>();
    //记录上一个节点,因为需要比较两个节点的值
    TreeNode pre = null;
    while (!stack.isEmpty() || root != null) {
        //一直往左访问
        if (root != null) {
            stack.push(root); // 将访问的节点放进栈
            root = root.left; // 左
        } else {
            //得到当前节点
            TreeNode temp = stack.pop();
            //处理当前节点
            if (pre != null && temp.val <= pre.val) {
                return false;
            }
            pre = temp;
            //右
            root = temp.right;
        }
    }
    return true;
}

时间复杂度O(N)

空间复杂度O(N)

统一迭代法

	public boolean isValidBST(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode pre = null;
        if(root != null)
            stack.add(root);        
        while(!stack.isEmpty()){
            TreeNode curr = stack.peek();
            if(curr != null){
                stack.pop();
                if(curr.right != null)
                    stack.add(curr.right);
                stack.add(curr);
                stack.add(null);
                if(curr.left != null)
                    stack.add(curr.left);
            }else{
                stack.pop();
                TreeNode temp = stack.pop();
                if(pre != null && pre.val >= temp.val)
                    return false;
                pre = temp;
            }
        }
        return true;
    }

时间复杂度O(N)

空间复杂度O(N)