day01

合并二叉树

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

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

返回合并后的二叉树。

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

递归法：
两个节点都有值：将树2的值加入到树1当中
只有一个节点有值：若节点1为空，节点2不为空，则用节点2代替
都没有值：返回节点1为null

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //至少有一个为空的情况
        if(root1 == null)return root2;
        if(root2 == null)return root1;

        //两个都不为空
        root1.val += root2.val;

        root1.left = mergeTrees(root1.left,root2.left);
        root1.right = mergeTrees(root1.right,root2.right);

        return root1;
    }
}

栈迭代法：

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //非空节点少于两个
        if(root1 == null)return root2;
        if(root2 == null)return root1;
		//非空节点为两个，先将该节点数据相加，在处理左右子节点
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root2);
        stack.push(root1);
        while(!stack.isEmpty()){
            TreeNode node1 = stack.pop();
            TreeNode node2 = stack.pop();
            node1.val += node2.val;
            if(node2.right != null && node1.right != null){
            	//有顺序，保证先拿出来的是node1的右节点
                stack.push(node2.right);
                stack.push(node1.right);
            }else{
                if(node1.right == null){
                    node1.right = node2.right;
                }
            }
            if(node2.left != null && node1.left != null){
                stack.push(node2.left);
                stack.push(node1.left);
            }else{
                if(node1.left == null){
                    node1.left = node2.left;
                }
            }
        }
    return root1;
    }
}

队列迭代法：
本质没区别，就是加入集合顺序换了，其他没变

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();
            node1.val += node2.val;
            
            if(node1.left != null && node2.left != null){
                queue.offer(node1.left);
                queue.offer(node2.left);
            }else{
                if(node1.left == null){
                    node1.left = node2.left;
                }
            }
            if (node1.right != null && node2.right != null) {
                queue.offer(node1.right);
                queue.offer(node2.right);
            }else{
                if(node1.right == null){
                    node1.right = node2.right;
                }
            }
        }

	return root1;
	}
}

二叉搜索树中的搜索

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

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

递归法：

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
    	//节点为空（没有目标）或找到目标，返回该节点
        if(root == null || root.val == val)return root;
        //在改搜索树的子节点中查找
        return root.val > val ? searchBST(root.left,val) : searchBST(root.right,val);
    }
}

迭代法：

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        while (root != null) {
            if (val == root.val) {
                return root;
            }
            root = val < root.val ? root.left : root.right;
        }
        return null;
    }
}

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/search-in-a-binary-search-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。