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

已于 2024-07-09 01:40:55 修改
阅读量266 收藏 4
点赞数 8
分类专栏： 代码随想录 文章标签： 算法 数据结构 java 学习 leetcode
于 2024-07-09 01:38:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_60364343/article/details/140282288
版权

文章目录

654.最大二叉树

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

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

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

示例 1：

img

输入：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：

img

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

提示：

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

Related Topics

  • 栈

  • 树

  • 数组

  • 分治

  • 二叉树

  • 单调栈

思路

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

654.最大二叉树

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

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

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

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

public TreeNode travel(int[] nums,int begin,int end){
    
}
  1. 确定终止条件

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

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

代码如下：

		//递归出口
		//已经没有元素了
		if(end-begin<1) {
			return null;
		}
		if(end-begin==1) {
			return new TreeNode(nums[begin]);
		}
  1. 确定单层递归的逻辑

这里有三步工作

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

代码如下：

		//找到最大值所在位置
		int maxIndex = begin;
		int maxVal = nums[maxIndex];
		for (int i = begin; i < end; i++) {
			if(nums[i]>maxVal)
			{
				maxIndex = i;
				maxVal = nums[maxIndex];
			}
		}
  1. 最大值所在的下标左区间 构造左子树

代码如下：

		//设置当前节点
		TreeNode temp = new TreeNode(maxVal);
		//向左子树遍历添加
		temp.left = travel(nums,begin,maxIndex);
  1. 最大值所在的下标右区间 构造右子树
		//向右子树遍历添加
		temp.right = travel(nums,maxIndex+1,end);
  1. 最后返回当前节点
		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：

img

输入：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.合并二叉树

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

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

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

代码如下：

	private TreeNode travel(TreeNode root1, TreeNode root2) {
		...
	}
  1. 确定终止条件：
		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
  1. 确定单层递归的逻辑：

单层递归的逻辑就比较好写了，这里我们重复利用一下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:

img

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

示例 2:

img

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

提示：

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

Related Topics

  • 树
  • 二叉搜索树
  • 二叉树

思路

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

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

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

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

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

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

递归法

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

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

代码如下：

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

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

		//没找到目标节点,返回null
		if(root==null) {
			return null;
		}	
		//找到了目标节点,返回root
		if (root.val==val) {
			return root;
		}
  1. 确定单层递归的逻辑

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

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

如果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：

img

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

示例 2：

img

输入：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类型的返回值。

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

  1. 确定终止条件

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

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

代码如下：

	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)

君君超有趣
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode98. 验证二叉搜索树
12-20
给定一个二叉树，判断其是否是一个有效的二叉搜索树。 假设一个二叉搜索树具有如下特征： 节点的左子树只包含小于当前节点的数。 节点的右子树只包含大于当前节点的数。 所有左子树和右子树自身必须也是二叉搜索树。...
LeetCode 331. 验证二叉树的前序序列化
12-21
序列化二叉树的一种方法是使用前序遍历。 当我们遇到一个非空节点时，我们可以记录下这个节点的值。 如果它是一个空节点，我们可以使用一个标记值记录，例如 #。 _9_ / \ 3 2 / \ / \ 4 1 # 6 / \ / \ / \ # # ...
代码随想录算法训练营第15天|LeetCode 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树
summersnowzgq的博客
06-29 845
思路：使用前序遍历递归构造二叉树。每次递归找出当前数组的位置范围中的最大值，作为当前节点对象，然后按照最大值位置切割数组，进行下一次递归，获取当前对象的左右节点对象。注意：1️⃣构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树。2️⃣每次分隔不用定义新的数组，而是通过下标索引直接在原数组上操作。
代码随想录第二十天|Leetcode654.最大二叉树、Leetcode617.合并二叉树、Leetcode700.二叉搜索树中的搜索、Leetcode98.验证二叉搜索树
muzi_taibai的博客
02-20 129
代码随想录第二十天|Leetcode654.最大二叉树、Leetcode617.合并二叉树、Leetcode700.二叉搜索树中的搜索、Leetcode98.验证二叉搜索树
代码随想录算法训练营第二十天| LeetCode654. 最大二叉树、LeetCode617. 合并二叉树、LeetCode700. 二叉搜索树中的搜索、LeetCode98. 验证二叉搜索树
weixin_48323589的博客
10-31 147
代码随想录算法训练营第二十天| LeetCode654. 最大二叉树、LeetCode617. 合并二叉树、LeetCode700. 二叉搜索树中的搜索、LeetCode98. 验证二叉搜索树
代码随想录算法训练营第18天| LeetCode654. 最大二叉树 | 617.合并二叉树 | 700.二叉搜索树中的搜索 | 98.验证二叉搜索树
qq_45077485的博客
07-08 517
二叉树专题part05，构造二叉树，合并二叉树，二叉搜索树
代码随想录算法训练营 Day19 | LeetCode654.最大二叉树、LeetCode617.合并二叉树、LeetCode700.二叉搜索树中的搜索、LeetCode98.验证二叉搜索树
ckw_lztxdy的博客
02-20 357
一个最直白的思路就是，先按照前序遍历二叉树，二叉搜索树的前序遍历应该是递增的，由此来验证，但此时时间空间复杂度就高，其实可以在遍历二叉树的时候就判断是否为搜索树。注：测试用例中包含了INT_MIN,所以这里要用LONG_MIN,但如果测试用例包含了LONG_MIN，这种方法就失效了。容易陷入的误区：搜索树应该是根节点的值要大于所有左子树的值，小于所有右子树的值，而不单单大于左节点，小于右节点。3、保证两棵树的遍历顺序相同，前序遍历比较简单。1、如果一个节点为空，则直接返回另一个节点。
代码随想录算法训练营Day18 | LeetCode | 654.最大二叉树 | 617.合并二叉树 | 700.二叉搜索树中的搜索 | 98.验证二叉搜索树
最新发布
wonderlandlja的博客
07-08 359
【代码】代码随想录算法训练营Day19 | LeetCode | 654.最大二叉树 | 617.合并二叉树 | 700.二叉搜索树中的搜索 | 98.验证二叉搜索树。
代码随想录算法训练营第二十天| LeetCode654.最大二叉树、LeetCode700.二叉搜索树中的搜索、LeetCode617.合并二叉树、LeetCode98.验证二叉搜索树
qq_42498113的博客
03-13 133
代码随想录算法训练营第二十天| LeetCode654.最大二叉树、LeetCode700.二叉搜索树中的搜索、LeetCode617.合并二叉树、LeetCode98.验证二叉搜索树
代码随想录算法训练营第20天| Leetcode 654.最大二叉树、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树
Camellia__Wang的博客
01-30 856
今天的题比较基础，完成的比较轻松，可以用来复习二叉树的基础内容。最后，如果文章有错误，请在评论区或私信指出，让我们共同进步！
代码随想录算法训练营Day19 || leetCode 654.最大二叉树 || 111.617.合并二叉树 || 700.二叉搜索树中的搜索 || 98.验证二叉搜索树
qq_44884699的博客
02-16 360
654.最大二叉树654.最大二叉树使用递归回溯的方法，并且可以借用之前利用前序中序数组写二叉树的方法，直接对数组nums的序号进行操作，可以减少重构数组的内存617.合并二叉树直接对root1进行操作700.二叉搜索树中的搜索首先要明白，二叉搜索树和二叉树的区别这就决定了，二叉搜索树，递归遍历和迭代遍历和普通二叉树都不一样。此题注意先判断节点是否为NULL，再判断val的关系。后序则利用二叉搜索树的规律来找关系。
代码随想录算法训练营第十九天 | LeetCode 654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树
Hsusan的博客
10-11 188
【代码】代码随想录算法训练营第十九天 | LeetCode 654. 最大二叉树、617. 合并二叉树、700. 二叉搜索树中的搜索、98. 验证二叉搜索树。
php-leetcode题解之二叉搜索树中的搜索.zip
06-08
在本压缩包“php-leetcode题解之二叉搜索树中的搜索.zip”中，主要包含的是关于使用PHP解决LeetCode上二叉搜索树（BST）搜索问题的代码和解析。LeetCode是一个在线平台，提供了大量的编程题目，用于提升开发者的技术...
php-leetcode题解之合并二叉树.zip
06-09
在计算机科学中，二叉树常用于构建搜索和排序算法，如二叉搜索树和堆。 合并二叉树的问题通常描述为：给定两个二叉树，它们的节点值可能代表某种形式的序列或集合，我们需要将这两个树合并成一个新的二叉树，使得新...
php-leetcode题解之验证二叉搜索树.zip
06-13
在本压缩包“php-leetcode题解之验证二叉搜索树.zip”中，主要包含的是使用PHP语言解决LeetCode上的一道题目——验证二叉搜索树（Validate Binary Search Tree）。LeetCode是一个流行的在线编程挑战平台，它提供了...
java-leetcode题解之第98题验证二叉搜索树.zip
06-18
这个“java-leetcode题解之第98题验证二叉搜索树.zip”压缩包文件显然是针对LeetCode上的第98题提供的Java解决方案。这道题目涉及的核心知识点是二叉搜索树（Binary Search Tree, BST）和树的遍历。 **二叉搜索树**...
LeetCode精选TOP面试题108.将有序数组转换为二叉搜索树
02-15
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 将有序数组转换为二叉搜索树的结果肯定是不唯一的，因为存在...
AlgorithmAndLeetCode#itcharge-LeetCode-Py#0501. 二叉搜索树中的众数1
07-25
0501. 二叉搜索树中的众数标签：树、深度优先搜索、二叉搜索树、二叉树难度：简单题目大意给定一个有相同值的二叉搜索树（BST），要求找出 BST 中所有众数
java-leetcode题解之第109题有序链表转换二叉搜索树.zip
06-18
在本压缩包中，我们关注的是Java编程语言与LeetCode平台上的第109题——有序链表转换为二叉搜索树（Convert Sorted List to Binary Search Tree）。这是一道涉及数据结构与算法的问题，主要涵盖了链表操作和二叉搜索...
LeetCode 精选 TOP 面试题（3）1
08-04
2. 再依次扩展根节点的左右儿子，也就是从左到右扩展第二层节点；3. 再依次从左到右扩展第三层节点；4. 依次类推然后在遍历过程中我们给每一层加一个结尾标记 N

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值