力扣算法 654. 最大二叉树 617. 合并二叉树 700. 二叉搜索树中的搜索

菜菜要要努力

于 2022-10-18 00:25:43 发布

阅读量69

点赞数

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/m0_51982291/article/details/127379539

版权

学习内容

力扣算法

654. 最大二叉树

617. 合并二叉树

700. 二叉搜索树中的搜索

具体内容

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 中的所有整数 互不相同

题目地址

做题思路

求数组的最大数，即为根节点，之后递归

解题

class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
    	if(nums.length == 0 || nums == null){
            return null;
        }
        return traversal(nums,0,nums.length);
    }
    public TreeNode traversal(int[] nums,int numsBegin,int numsEnd){
        if(numsBegin >= numsEnd){
            return null;
        }
        if (numsEnd - numsBegin == 1) {// 只有一个元素
            return new TreeNode(nums[numsBegin]);
        }
        int big = numsBegin;
        int result = nums[numsBegin];
        //找寻根节点
        for(int i=big+1;i < numsEnd;i++){
            if(nums[i] > result){
                big = i;
                result = nums[i];
            }
        }
        //创建节点
        TreeNode node = new TreeNode(result);
        node.left = traversal(nums,numsBegin,big);
        node.right = traversal(nums,big+1,numsEnd);
        return node;
    }
 }

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

题目地址

做题思路

以其中一个二叉数为主，加另一个二叉树各个节点的值，返回被加二叉树的值

解题

递归

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;
    } 
}

迭代

1、使用队列

class Solution {
    //以其中一颗二叉树相加返回值 而不用自己去创建新的二叉树
    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 = node1.val + node2.val;
            if(node1.left != null && node2.left != null){
                queue.offer(node1.left);
                queue.offer(node2.left);
            }
            if(node1.right != null && node2.right != null){
                 queue.offer(node1.right);
                queue.offer(node2.right);
            }
            if(node1.left == null && node2.left != null){
                node1.left = node2.left;
            }
            if(node1.right == null && node2.right != null){
                node1.right = node2.right;
            }
        }
        return root1;
    }
}

2、使用栈

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()){
       		//如果使用poll 则可能造成while结束
       		TreeNode node1 = stack.pop();
       		TreeNode node2 = stack.pop();
       		node1.val = node1.val + node2.val;
       		if(node1.left != null && node2.left != null){
       			stack.push(root2.left);
       			stack.push(root1.left);
       		}else{
       			if(node1.left == null){
       				node1.left = node2.left;       		
       			}
       		}
			if(node1.right!= null && node1.right != null){
       			stack.push(root2.right);
       			stack.push(root1.right);
       		}else{
       			if(node1.right == null){
       				node1.right = node2.right;       		
       			}
       		}
       }
       return root1;
    }
}

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

题目地址

做题思路

利用二叉搜索数的特性，比val小的为左节点，比val大的为右节点

解题

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