二叉树系列

已于 2022-05-11 14:08:32 修改
阅读量195 收藏
点赞数
分类专栏： 算法 文章标签： leetcode
于 2022-04-20 16:18:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38686500/article/details/124299121
版权
对于二叉树的题目来说，无非就是递归左右子树，需要注意的是自顶向下还是自下而上！

1、中序遍历二叉树

在这里插入图片描述

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        // 递归
        List<Integer> list = new LinkedList<>();
        dfs(root, list);
        return list;
        void dfs(TreeNode cur, List<Integer> list) {
            if (cur == null) return;
            dfs(cur.left, list);
            list.add(cur.val);
            dfs(cur.right, list);
       	}
		// 非递归
        List<Integer> list = new ArrayList<>();
        if (root == null){
            return list;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                list.add(cur.val);
                cur = cur.right;
            }
        }
        return list;
    }
}

2、相同的树

在这里插入图片描述

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q == null) {
            return true;
        } else if (p != null & q == null) {
            return false;
        } else if (p == null & q != null) {
            return false;
        }
        if (p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right)) {
            return true;
        } 
        return false;
    }
}

3、对称二叉树

在这里插入图片描述

class Solution {
    public boolean isSymmetric(TreeNode root) {
        return traverse(root.left, root.right);
    }

    boolean traverse(TreeNode a, TreeNode b) {
        if (a == null && b == null) {
            return true;
        } else if (a != null && b == null) {
            return false;
        } else if (a == null && b != null) {
            return false;
        }
        if (a.val == b.val && traverse(a.left, b.right) && traverse(a.right, b.left)) {
            return true;
        }
        return false;
    }
}

4、二叉树的最大深度

在这里插入图片描述

class Solution {
    int max = 0;
    public int maxDepth(TreeNode root) {
        traverse(root, 0);
        return max;
    }

    int traverse(TreeNode root, int depth) {
        if (root == null) return depth;
        depth++;
        if (depth > max) {
            max = depth;
        }
        traverse(root.left, depth);
        traverse(root.right, depth);
        return depth;
    }
}

5、将有序数组转换为二叉搜索树

在这里插入图片描述

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return traverse(nums, 0, nums.length-1);
    }

    TreeNode traverse(int[] nums, int left, int right) {
        if (left > right) return null;
        int mid = (left + right) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = traverse(nums, left, mid-1);
        root.right = traverse(nums, mid+1, right);
        return root;
    }
}

6、平衡二叉树

在这里插入图片描述

class Solution {
    boolean flag = true;
    public boolean isBalanced(TreeNode root) {
        int res = traverse(root);
        if (res > -1) {
            return true;
        }
        return false;
    }

    int traverse(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int l = traverse(root.left);
        int r = traverse(root.right);
        if (l == -1 || r == -1 || Math.abs(l-r) > 1) {
            return -1;
        } else {
            return Math.max(l, r) + 1;
        }
    }
}

7、二叉树的最小深度

在这里插入图片描述

class Solution {
    public int minDepth(TreeNode root) {
        return minL(root);
    }

    int minL(TreeNode root) {
        if (root == null) return 0;
        int l = minL(root.left);
        int r = minL(root.right);
        if (l == 0) {
            return r + 1;
        } else if (r == 0) {
            return l + 1;
        }
        return Math.min(l, r) + 1;
    }
}

8、路径总和

在这里插入图片描述

class Solution {
    public boolean hasPathSum(TreeNode root, int sum) {
        if (root == null) {
            return false;
        }
        if (root.left == null && root.right == null) {
            return sum == root.val;
        }
        return hasPathSum(root.left, sum - root.val) || hasPathSum(root.right, sum - root.val);
    }
}

9、二叉树的前序遍历

在这里插入图片描述

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        return list;
    }
    void dfs (TreeNode cur, List<Integer> list) {
        if (cur == null) return;
        list.add(cur.val);
        dfs(cur.left, list);
        dfs(cur.right, list);
    }
}

10、二叉树的后序遍历

在这里插入图片描述

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        dfs(root, list);
        return list;
    }
    void dfs(TreeNode node, List<Integer> list) {
        if (node == null) return;
        dfs(node.left, list);
        dfs(node.right, list);
        list.add(node.val);
    }
}

11、翻转二叉树

在这里插入图片描述

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if (root == null) return null;
        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);
        root.left = right;
        root.right = left;
        return root;
    }
}

12、二叉搜索树的最近公共祖先

在这里插入图片描述

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null) return null;
        if (root == p || root == q) return root;
        
        TreeNode left = null;
        TreeNode right = null;
        if (p.val > root.val && q.val > root.val) {
            right = lowestCommonAncestor(root.right, p, q);
        } else if (p.val < root.val && q.val > root.val) {
            left = lowestCommonAncestor(root.left, p, q);
            right = lowestCommonAncestor(root.right, p, q);
        } else if (q.val < root.val && p.val > root.val) {
            left = lowestCommonAncestor(root.left, p, q);
            right = lowestCommonAncestor(root.right, p, q);
        } else if (p.val < root.val && q.val < root.val) {
            left = lowestCommonAncestor(root.left, p, q);
        }
        
        if (left != null && right != null) return root;
        if (left != null && right == null) return left;
        if (left == null && right != null) return right;
        if (left == null && right == null) return null;
        return null;
    }
}

13、二叉树的所有路径

在这里插入图片描述

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();
        getPath(root, "", res);
        return res;
    }

    void getPath(TreeNode root, String path, List<String> paths) {
        if (root != null) {
            path += root.val;
            if (root.left == null && root.right == null) {
                paths.add(path);
            } else if (root.left != null || root.right != null) {
                path += "->";
                getPath(root.left, path, paths);
                getPath(root.right, path, paths);
            }
        } 
    }
}

14、左叶子之和

在这里插入图片描述

// 需要注意的是，这里是左叶子之和不是左节点！！
class Solution {
    private int sum;
    public int sumOfLeftLeaves(TreeNode root) {
        sum = 0;
        traverse(root);
        return sum;
    }

    void traverse(TreeNode root) {
        if (root == null) return;

        if (root.left != null && root.left.left == null && root.left.right == null) {
            sum += root.left.val;
        }
        traverse(root.left);
        traverse(root.right);
    }
}

15、二叉树的坡度

需要注意审题，这里是左右子树之和的差
在这里插入图片描述

class Solution {
    int sum = 0;
    public int findTilt(TreeNode root) {
        traverse(root);
        return sum;
    }

    int traverse(TreeNode root) {
        if (root == null) return 0;

        int left = traverse(root.left);
        int right = traverse(root.right);
        sum += Math.abs(left - right);
        return root.val + left + right;
    }
}

16、二叉搜索树中的众数

在这里插入图片描述

class Solution {
    List<Integer> res = new LinkedList<>();
    int max = 0;
    int tempMax  = 0;
    TreeNode pre = null;
    public int[] findMode(TreeNode root) {
        traverse(root);
        int[] arr = res.stream().mapToInt(Integer::intValue).toArray();
        return arr;
    }

    void traverse(TreeNode root) {
        if (root == null) return;
        
        traverse(root.left);
        if (pre != null && root.val == pre.val) {
            tempMax++;
        } else {
            tempMax = 1;
        }
        if (tempMax == max){
            res.add(root.val);
        } else if (tempMax > max) {
            res.clear();
            max = tempMax;
            res.add(root.val);
        }
        pre = root;
        traverse(root.right);
    }
}

17、二叉搜索树的最小绝对差

在这里插入图片描述

class Solution {
    private TreeNode pre = null;
    int min = 0;
    boolean flag = false;  // 判断是否初始化了min
    public int getMinimumDifference(TreeNode root) {
        traverse(root);
        return min;
    }

    void traverse(TreeNode cur) {
        if (cur == null) return;

        traverse(cur.left);
        if (pre == null) {
            pre = cur;
        } else if (!flag) {
            flag = true;
            min = Math.abs(cur.val - pre.val);
        } else if (flag && Math.abs(cur.val-pre.val) < min) {
            min = Math.abs(cur.val - pre.val);
        }
        pre = cur;
        traverse(cur.right);
    }
}

18、二叉树的直径

在这里插入图片描述

class Solution {
    int ans;
    public int diameterOfBinaryTree(TreeNode root) {
        ans = 1;
        depth(root);
        return ans - 1;
    }
    public int depth(TreeNode node) {
        if (node == null) {
            return 0; // 访问到空节点了，返回0
        }
        int L = depth(node.left); // 左儿子为根的子树的深度
        int R = depth(node.right); // 右儿子为根的子树的深度
        ans = Math.max(ans, L+R+1); // 计算d_node即L+R+1 并更新ans
        return Math.max(L, R) + 1; // 返回该节点为根的子树的深度
    }
}

19、另一颗树的子树（此题有哈希解法）

在这里插入图片描述

class Solution {
    public boolean isSubtree(TreeNode s, TreeNode t) {
        return dfs(s, t);
    }

    public boolean dfs(TreeNode s, TreeNode t) {
        if (s == null) {
            return false;
        }
        return check(s, t) || dfs(s.left, t) || dfs(s.right, t);
    }

    public boolean check(TreeNode s, TreeNode t) {
        if (s == null && t == null) {
            return true;
        }
        if (s == null || t == null || s.val != t.val) {
            return false;
        }
        return check(s.left, t.left) && check(s.right, t.right);
    }
}

哈希

class Solution {
    static final int MAX_N = 1005;
    static final int MOD = 1000000007;
    boolean[] vis = new boolean[MAX_N];
    int[] p = new int[MAX_N];
    int tot;
    Map<TreeNode, int[]> hS = new HashMap<TreeNode, int[]>();
    Map<TreeNode, int[]> hT = new HashMap<TreeNode, int[]>();

    public boolean isSubtree(TreeNode s, TreeNode t) {
        getPrime();
        dfs(s, hS);
        dfs(t, hT);

        int tHash = hT.get(t)[0];
        for (Map.Entry<TreeNode, int[]> entry : hS.entrySet()) {
            if (entry.getValue()[0] == tHash) {
                return true;
            }
        }

        return false;
    }

    public void getPrime() {
        vis[0] = vis[1] = true;
        tot = 0;
        for (int i = 2; i < MAX_N; ++i) {
            if (!vis[i]) {
                p[++tot] = i;
            }
            for (int j = 1; j <= tot && i * p[j] < MAX_N; ++j) {
                vis[i * p[j]] = true;
                if (i % p[j] == 0) {
                    break;
                }
            }
        }
    }

    public void dfs(TreeNode o, Map<TreeNode, int[]> h) {
        h.put(o, new int[]{o.val, 1});
        if (o.left == null && o.right == null) {
            return;
        }
        if (o.left != null) {
            dfs(o.left, h);
            int[] val = h.get(o);
            val[1] += h.get(o.left)[1];
            val[0] = (int) ((val[0] + (31L * h.get(o.left)[0] * p[h.get(o.left)[1]]) % MOD) % MOD);
        }
        if (o.right != null) {
            dfs(o.right, h);
            int[] val = h.get(o);
            val[1] += h.get(o.right)[1];
            val[0] = (int) ((val[0] + (179L * h.get(o.right)[0] * p[h.get(o.right)[1]]) % MOD) % MOD);
        }
    }
}

20、根据二叉树创建字符串

这题主要是吓唬人，看清题意就行。
在这里插入图片描述

class Solution {
    public String tree2str(TreeNode root) {
        return dfs(root);
    }

    String dfs(TreeNode root) {
        if (root == null) return "-";
        String left = dfs(root.left);
        String right = dfs(root.right);

        if (left.equals("-") && right.equals("-")) {
            return root.val + "";
        } else if (!left.equals("-") && right.equals("-")) {
            return root.val + "(" + left + ")";
        } else if (left.equals("-") && !right.equals("-")) {
            return root.val + "()"  + "(" + right+ ")";
        } else if (!left.equals("-") && !right.equals("-")) {
            return root.val + "(" + left + ")" + "(" + right +")";
        }
        return "-"; 
    }
}

21、合并二叉树

在这里插入图片描述

class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        if (root1 == null) {
            return root2;
        }
        if (root2 == null) {
            return root1;
        }
        TreeNode merged = new TreeNode(root1.val + root2.val);
        merged.left = mergeTrees(root1.left, root2.left);
        merged.right = mergeTrees(root1.right, root2.right);
        return merged;
    }
}
吼吼权
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树系列题目
Harris-H的博客
03-19 1145
二叉树系列题目 1.利用二叉树性质解题. UVA 679 - Dropping Balls 有一棵二叉树，最大深度为D，且所有叶子的深度都相同。所有结点从上到下从左到右 编号为1, 2, 3,…, 2D-1。在结点1处放一个小球，它会往下落。每个内结点上都有一个开关， 初始全部关闭，当每次有小球落到一个开关上时，状态都会改变。当小球到达一个内结点 时，如果该结点上的开关关闭，则往左走，否则往右走...
手把手刷二叉树系列完结篇
fdl123456的博客
12-24 804
后台回复进群一起刷力扣点击卡片可搜索关键词????读完本文，可以去力扣解决如下题目：104. 二叉树的最大深度（Easy）543.二叉树的直径（Easy）144. 二叉树的前序遍历（Easy）...
《剑指Offer》之二叉树系列(1)
xiao_ma_CSDN的博客
08-19 193
1.输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构） 分析： 判断root1和root2的根结点是否相同，相同则进一步判断root1的子树和root2的子树是否相同。 root1和root2的根结点不同，则用roo1的左右子树跟root2比较，直到root1为空时结束。 当root1为null 且root2不为null，返回false; 当roo...
二叉线索树
xiaohudeITmeng的博客
05-24 1709
二叉树的定义：                  由于在二叉树的链式存储结构中，每个结点存储了指向其左右孩子结点的链，而没有存储指向某种线索性次序下的前驱或者后继结点的链。当需要获得结点在一种遍历序列中的前驱或者后继结点时。有俩中解决方案： （1）再进行一次遍历，寻找前驱或后继结点。这需要花费较多的时间，效率较低。 （2）采用多重链表结构，每个结点增加俩条链，分别指向前驱和后继结点。需要花费较多的
线索化二叉树
Ronz 的博客
01-21 1550
一、线索二叉树概述 在二叉树的节点上加上线索的二叉树称为线索二叉树。对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。 通过考察各种二叉链表，不管二叉树的形态如何，空链域的个数总是多过非空链域的个数。准确的说，n 个节点的二叉链表共有 2n 个链域，其中非空链域为 n-1 个，但空链域却有 n+1 个。如下图所示，二叉树有 6 个节点，其中非空链域的个数为 7 个。 利用这些空链域存放在某种遍历次序下该结点的前驱结点和后继结点的指针，这些指针
剑指Offer之二叉树系列：从上往下打印二叉树(I、II、III)、二叉树中和为某一值的路径
12-21
【二叉树的层次遍历】是数据结构中二叉树的一种重要操作，它涉及到的主要算法是广度优先搜索（BFS）。这个问题的核心是利用队列的先进先出（FIFO）特性，按照从上到下，从左到右的顺序逐层遍历并打印二叉树的所有...
二叉树系列1.md
11-17
二叉树系列1.md
二叉树的系列操作
12-16
本次实验为二叉树的系列操作。希望可以通过本次实验对大家有所帮助。
二叉树系列 各种常见操作C语言实现
02-18
各种二叉树的常见操作 递归输出 非递归输出 三种遍历包含递归和非递归方式
leetcode 二叉树-1
02-09
在LeetCode的二叉树算法系列中，我们通常会遇到各种类型的二叉树问题。以下是对二叉树的一些核心概念的详细解释： 1. **二叉树的种类**： - **满二叉树**：所有层的节点都完全填充，除了可能的最后一层，最后一层...
力扣224.基本计算器
Pisasama的博客
07-14 228
【代码】力扣224.基本计算器。
力扣-bfs
weixin_63551790的博客
07-12 528
何为广度优先搜索？广度优先搜索，即bfs。不同于dfs（走到底然后再换另外一条路），bfs更像是一层一层的走。常常用来处理最短路径问题。
leetcode_88. 合并两个有序数组
qq_42742845的博客
07-14 884
给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。请你 合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。
力扣1111.有效括号的嵌套深度
Pisasama的博客
07-14 345
对于。
Golang | Leetcode Golang题解之第233题数字1的个数
weixin_66442839的博客
07-14 242
Golang | Leetcode Golang题解之第233题数字1的个数
LeetCode --- 2138. Divide a String Into Groups of Size k 解题报告
最新发布
杨鑫newlife的专栏
07-16 1322
A string can be partitioned into groups of size using the following procedure:Note that the partition is done so that after removing the character from the last group (if it exists) and concatenating all the groups in order, the resultant string should
leetcode 283. 移动零
qq_20411067的博客
07-13 321
但是对于这一题而言，因为它需要交换的是0和另外一个非0数，所以我们可以直接覆盖0即可。最后再把0补上就行。用index记录已经覆盖到的位置，把从index到nums.length处的元素全部设为0即可。使用双指针：慢指针左边均为非0元素；快指针左边到左指针都为0。我们只需要不断的去交换这两个指针位置的元素即可。
【LeetCode】：62：不同路径
2401_83821949的博客
07-12 262
【代码】【LeetCode】：62：不同路径。
Leetcode（经典题）day3-双指针
WYZFJHH的博客
07-14 279
直接双指针对比就行。
LeetCode二叉树系列：全面解析与遍历方法
在LeetCode的二叉树系列中，我们可以通过一系列的题目来深入理解和掌握二叉树的相关知识。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。二叉树在计算机科学中有着广泛的应用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值