2022.03.18力扣617，700，98，530，501

最新推荐文章于 2024-08-10 23:59:21 发布

一桶锅包肉

最新推荐文章于 2024-08-10 23:59:21 发布

阅读量268

点赞数 1

分类专栏：算法题文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/weixin_43659314/article/details/123565480

版权

算法题专栏收录该内容

58 篇文章 1 订阅

订阅专栏

学习二叉树

follow：代码随想录

617 合并二叉树

题目描述：
给你两棵二叉树： root1 和 root2 。

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

返回合并后的二叉树。
在这里插入图片描述
解答：
递归法：

public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        //递归法+前序遍历
        if(root1 == null && root2 == null) return null;
        if(root1 == null && root2 != null) return root2;
        if(root1 != null && root2 == null) return root1;
        TreeNode root = new TreeNode(root1.val + root2.val);
        root.left = mergeTrees(root1.left, root2.left);
        root.right = mergeTrees(root1.right, root2.right);
        return root;
    }

迭代法：

 public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if(root1 == null) return root2;
        if(root2 == null) return root1;
        //迭代法：使用root1作为中心元素
        //使用队列来保存
        Deque<TreeNode> queue = new LinkedList<>();
        queue.offerLast(root1);
        queue.offerLast(root2);
        while(!queue.isEmpty()){
            TreeNode node1 = queue.pollFirst();
            TreeNode node2 = queue.pollFirst();
            //此时两个节点一定不为空
            node1.val += node2.val;
            //处理左右节点
            if(node1.left != null && node2.left != null){
                queue.offerLast(node1.left);
                queue.offerLast(node2.left);
            }
            if(node1.right != null && node2.right != null){
                queue.offerLast(node1.right);
                queue.offerLast(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;
    }

700 二叉搜素树中的搜索

二叉搜素树：

若他的左子树不为空，则左子树的所有节点均小于根节点的值
若他的左子树不为空，则右子树的所有节点均大于根节点的值
左、右子树均为二叉搜索树

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

98 验证二叉搜索树

注：该题不能简单的判断为：根节点的值大于左子节点的值，根节点的值小于右子节点的值。
二叉搜索树的中序遍历是递增的！
递归法：

class Solution {
    //中序遍历
    TreeNode pre = null;
    public boolean isValidBST(TreeNode root) {
        //终止条件，意味着遍历结束
        if(root == null) return true;
        //左子树
        boolean flag1 = isValidBST(root.left);
        if(flag1 == false) return false;
        //中间节点 严格递增
        if(pre != null && pre.val >= root.val){
            return false;
        }else{
            pre = root;
        }
        //右子树
        boolean flag2 = isValidBST(root.right);
        if(flag2 == false) return false;

        return true;
    }
}

迭代：

public boolean isValidBST(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        stack.addFirst(root);
        TreeNode pre = null;
        while(!stack.isEmpty()){
            TreeNode node = stack.removeFirst();
            if(node != null){
                if(node.right != null) stack.addFirst(node.right);
                stack.addFirst(node);
                stack.addFirst(null);
                if(node.left != null) stack.addFirst(node.left);
            }else{
                node = stack.removeFirst();
                //严格递增
                if(pre != null && node.val <= pre.val) return false;
                else{
                    pre = node;
                }
            }
        }
        return true;
    }

530 二叉搜索树的最小绝对差

题目描述：
给你一个二叉搜索树的根节点 root ，返回树中任意两不同节点值之间的最小差值。

差值是一个正数，其数值等于两值之差的绝对值。

解析：
中序遍历后即是一个有序的，在这上面找到最小差值
递归法：

class Solution {
    //在有序数组上求最小差值
    int min = Integer.MAX_VALUE;
    //记录前一个节点
    TreeNode pre = null;
    public int getMinimumDifference(TreeNode root) {
        findMinimum(root);
        return min;
    }

    public void findMinimum(TreeNode node){
        if(node == null) return;
        //中序遍历
        findMinimum(node.left);
        if(pre != null && min > (node.val - pre.val)) min = node.val - pre.val;
        pre = node;
        findMinimum(node.right);
    }
}

迭代法：

 public int getMinimumDifference(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        stack.addFirst(root);
        TreeNode pre = null;
        int min = Integer.MAX_VALUE;
        while(!stack.isEmpty()){
            TreeNode node = stack.removeFirst();
            if(node != null){
                if(node.right != null) stack.addFirst(node.right);
                stack.addFirst(node);
                stack.addFirst(null);
                if(node.left != null) stack.addFirst(node.left);
            }else{
                node = stack.removeFirst();
                if(pre != null && min > (node.val - pre.val)) min = node.val - pre.val;
                pre = node;
            }
        }
        return min;
    }

501 二叉搜索树中的众数

题目描述：
给你一个含重复值的二叉搜索树（BST）的根节点 root ，找出并返回 BST 中的所有众数（即，出现频率最高的元素）。

如果树中有不止一个众数，可以按任意顺序返回。

解答：
递归法：

class Solution {
    //记录计数最大值
    int max = Integer.MIN_VALUE;
    //记录当前计数
    int count = 0;
    //结果集合
    List<Integer> res = new ArrayList<>();
    //前一个节点
    TreeNode pre = null;
    public int[] findMode(TreeNode root) {
        mode(root);
        int[] result = new int[res.size()];
        for(int i = 0; i < res.size(); i++){
            result[i] =res.get(i);
        }
        return result;
    }

    public void mode(TreeNode root){
        if(root == null) return;
        mode(root.left);

        if(pre == null || pre.val != root.val)
            count = 1;
        else 
            count++;

        if(max < count){
            max = count;
            res.clear();
            res.add(root.val);
        }else if(max == count){
            res.add(root.val);
        }     
        pre = root;

        mode(root.right);
    }
}

迭代法：

public int[] findMode(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode pre = null;
        int max = Integer.MIN_VALUE;
        int count = 0;
        List<Integer> res = new ArrayList<>();
        stack.addFirst(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.removeFirst();
            if(node != null){
                if(node.right != null) stack.addFirst(node.right);
                stack.addFirst(node);
                stack.addFirst(null);
                if(node.left != null) stack.addFirst(node.left); 
            }else{
                node = stack.removeFirst();
                if(pre == null || node.val != pre.val){
                    count = 1;
                }else if(node.val == pre.val) count++;
                if(max < count){
                    max = count;
                    res.clear();
                    res.add(node.val);
                }else if(max == count){
                    res.add(node.val);
                }
                pre = node;
            }
        }
        int[] result = new int[res.size()];
        for(int i = 0; i < res.size(); i++){
            result[i] = res.get(i);
        }
        return result;
    }

一桶锅包肉

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2022.03.18力扣617，700，98，530，501

学习二叉树follow：代码随想录617 合并二叉树题目描述：给你两棵二叉树： root1 和 root2 。想象一下，当你将其中一棵覆盖到另一棵之上时，两棵树上的一些节点将会重叠（而另一些不会）。你需要将这两棵树合并成一棵新二叉树。合并的规则是：如果两个节点重叠，那么将这两个节点的值相加作为合并后节点的新值；否则，不为 null 的节点将直接作为新二叉树的节点。返回合并后的二叉树。解答：递归法：public TreeNode mergeTrees(TreeNode root1, Tr
复制链接

扫一扫

专栏目录