数据结构:二叉树(2)

二叉树的基本操作

获取树的结点总数

遍历思路:

每次遍历一个节点,遍历完nodeSize++,然后遍历它的左右子树

如果遍历到空的节点,就返回0

java 复制代码
    public int nodeSize = 0;
    int size(TreeNode root){
        if(root == null){
            return 0;
        }
        nodeSize++;
        size(root.left);
        size(root.right);
        return nodeSize;
    }

子树相加思路

整棵树的节点个数 = 左子树的节点个数+右子树的节点个数 + 根节点

java 复制代码
    int size2(TreeNode root){
        if(root == null){
            return 0;
        }
        return size2(root.left) + size2(root.right) + 1;
    }

size2(root.left) 可以理解为左子树所有节点的总数

size2(root.right)可以理解为右子树所有节点的总数


计算二叉树叶结点的总数

遍历思路:遍历结点和左右子树,如果遍历到有一个结点左右子树都为null,那么这个结点就是叶结点,计数器++

java 复制代码
    // 获取叶子节点的个数
    //遍历思路
    public int leafNode = 0;
    int getLeafNodeCount(TreeNode root){
        if(root == null){
            return 0;
        }
        if(root.left == null && root.right == null){
            leafNode++;
        }
        getLeafNodeCount(root.left);
        getLeafNodeCount(root.right);
        return leafNode;
    }

子树相加思路:整棵树叶子 = 左子树叶子 + 右子树叶子

java 复制代码
    //子树相加思路
    int getLeafNodeCount2(TreeNode root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        return getLeafNodeCount2(root.left) + getLeafNodeCount2(root.right);
    }

获取第k层的结点个数

思路:

整棵树第k层节点数 = 左子树第k-1层结点数+右子树第k-1层结点数

感觉有杨辉三角的感觉(bushi

java 复制代码
    // 获取第K层节点的个数
    public int nodeCount = 0;
    int getKLevelNodeCount(TreeNode root,int k){
        if(root == null){
            return 0;
        }
        if(k == 1){
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1) + getKLevelNodeCount(root.right,k-1);
    }

求二叉树的高度

高度就是最大层数,整棵树的高度 = 左子树的高度和右子树的高度的最大值+1

A的左子树是B,右子树是C

那B的高度怎么求呢?很简单,再递归一下呗,把B当成根结点,左子树B高度就等于B的左子树和右子树高度最大值+1

这样递归递归就能求出左子树总高度了,右子树也同理

java 复制代码
    int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        
        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }

换种写法

java 复制代码
    int getHeight2(TreeNode root){
        if(root == null){
            return 0;
        }

        return getHeight2(root.left) > getHeight2(root.right) 
                ? getHeight2(root.left) + 1 : getHeight2(root.right) + 1;
    }

第二种写法放编译器可以跑,但是放到力扣跑不了

104. 二叉树的最大深度 - 力扣(LeetCode)

它会报这么一个错误

原因就是return的时候好不容易递归完判断左右子树大小,还得再重复递归一次计算总高度,所以跑太久力扣就给你报超时的错误了


检测特定值的元素是否存在

这个直接用前序遍历就行了

java 复制代码
    TreeNode find(TreeNode root, int val){
        if(root == null){
            return null;
        }
        //判断根结点是不是
        if(root.val == val){
            return root;
        }
        TreeNode ret = find(root.left, val);
        if(ret != null){
            return ret;//这样就不用去右边了
        }
        TreeNode ret2 = find(root.right,val);
        if(ret2 != null){
            return ret2;
        }
        return null;
    }

二叉树面试题

100. 相同的树 - 力扣(LeetCode)

给你两棵二叉树的根节点 pq ,编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同 ,并且节点具有相同的值,则认为它们是相同的。

示例 1:

复制代码
输入:p = [1,2,3], q = [1,2,3]
输出:true

示例 2:

复制代码
输入:p = [1,2], q = [1,null,2]
输出:false

示例 3:

复制代码
输入:p = [1,2,1], q = [1,1,2]
输出:false

提示:

  • 两棵树上的节点数目都在范围 [0, 100]
  • -104 <= Node.val <= 104

1.如果两个结点都不为空,就判断值

2.如果一个结点为空一个结点不为空,那必不一样

总结:判断根及其左子树和右子树是否相同

java 复制代码
class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if((p == null && q != null)||(p != null && q == null)){
            return false;
        }
        //上面代码走完后要么两个都为空,要么都不为空
        if(p == null && q == null){
            return true;
        }
        //只剩两个都不为空的情况
        if(p.val != q.val){
            return false;
        }

        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

572. 另一棵树的子树 - 力扣(LeetCode)

给你两棵二叉树 rootsubRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在,返回 true ;否则,返回 false

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

示例 1:

复制代码
输入:root = [3,4,5,1,2], subRoot = [4,1,2]
输出:true

示例 2:

复制代码
输入:root = [3,4,5,1,2,null,null,null,null,0], subRoot = [4,1,2]
输出:false

提示:

  • root 树上的节点数量范围是 [1, 2000]
  • subRoot 树上的节点数量范围是 [1, 1000]
  • -104 <= root.val <= 104
  • -104 <= subRoot.val <= 104

1.注意:如果是子树,有可能是两棵相同的树,那可以先比较根结点

2.如果根结点比较完发现不是两棵相同的树,那么subRoot这棵树和root的某一棵子树是相同的

3.判断subRoot和root的左子树是不是相同的,不是就判断右子树。都不是就false了

刚刚那个isSameTree()方法不久能用上了吗

java 复制代码
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if((p == null && q != null)||(p != null && q == null)){
            return false;
        }
        //上面代码走完后要么两个都为空,要么都不为空
        if(p == null && q == null){
            return true;
        }
        //只剩两个都不为空的情况
        if(p.val != q.val){
            return false;
        }

        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(isSameTree(root,subRoot)){
            return true;
        }
        if(isSubtree(root.left,subRoot)){
            return true;
        }
        if(isSubtree(root.right,subRoot)){
            return true;
        }
        return false;
    }

欸但是力扣直接给我报了一个空指针异常

这是因为假如root的左子树就是空的,root第一个if判断完之后进入左子树变成空,空指针进不了第二个if判断,所以跳过直接进入到右子树的if判断,那此时root都为空了,系统自然就报了一个空指针异常了

🆗其实我们在判断根结点是否相同前先判断会不会有空就行了

java 复制代码
        if(root == null || subRoot == null){
            return false;
        }

226. 翻转二叉树 - 力扣(LeetCode)

给你一棵二叉树的根节点 root ,翻转这棵二叉树,并返回其根节点。

示例 1:

复制代码
输入:root = [4,2,7,1,3,6,9]
输出:[4,7,2,9,6,3,1]

示例 2:

复制代码
输入:root = [2,1,3]
输出:[2,3,1]

示例 3:

复制代码
输入:root = []
输出:[]

提示:

  • 树中节点数目范围在 [0, 100]
  • -100 <= Node.val <= 100

相当于我们进行数组交换一样

每次遍历到一个结点,就把这个结点的两个引用都换一下就好了

直到所有结点都遍历完成

java 复制代码
class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        if(root.left == null && root.right == null){
            return root;
        }
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        //递归搞左右树
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }
}

110. 平衡二叉树 - 力扣(LeetCode)

给定一个二叉树,判断它是否是高度平衡的二叉树。

本题中,一棵高度平衡二叉树定义为:

一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1 。

示例 1:

复制代码
输入:root = [3,9,20,null,null,15,7]
输出:true

示例 2:

复制代码
输入:root = [1,2,2,3,3,null,null,4,4]
输出:false

示例 3:

复制代码
输入:root = []
输出:true

提示:

  • 树中的节点数在范围 [0, 5000]
  • -104 <= Node.val <= 104

思路:

1.判断当前根结点的左子树高度-右子树高度的绝对值是否<=1

2.根的左子树是平衡的并且右子树也得是平衡的

这道题高度方法前面已经写完了,直接调用就行(getHeight())

java 复制代码
class Solution {
    public int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);

        return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
    }
    public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }
        //分别求左右树高度
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        //判断绝对差值<=1并且左右子树都平衡
        return Math.abs(leftHeight-rightHeight) <= 1 
        && isBalanced(root.left) && isBalanced(root.right);
    }
}

这里的时间复杂度是O(N^2),在求左子树和右子树高度调用getHeight时间复杂度已经是O(N)了,return部分再调用isBalance,相当于又遍历了一遍所有的n个结点,isBalance嵌套了getHeight,时间复杂度就是n*n了

进阶难度:使用O(N)的时间复杂度来计算

我们在求子树高度的时候,返回高度时直接让他们进行比较,如果>1就返回-1给根结点

java 复制代码
class Solution {
    public int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);

        if(leftHeight >= 0 && rightHeight>=0
        && Math.abs(leftHeight - rightHeight)<=1){
          //返回真实高度
          return Math.max(leftHeight,rightHeight)+1;
        }else{
          return -1;
        }
    }
    public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return getHeight(root) >= 0;
    }
}

达到O(n)的时间复杂度


101. 对称二叉树 - 力扣(LeetCode)

给你一个二叉树的根节点 root , 检查它是否轴对称。

示例 1:

复制代码
输入:root = [1,2,2,3,4,4,3]
输出:true

示例 2:

复制代码
输入:root = [1,2,2,null,3,null,3]
输出:false

提示:

  • 树中节点数目在范围 [1, 1000]
  • -100 <= Node.val <= 100

不对称:

1.一个为空另一个不为空

2.值不一样

3.左树的左和右树的左对称?左树的右和右树的左对称?

注意:left和right都为空就是对称

java 复制代码
    public boolean isSymmetric(TreeNode root) {
        if(root == null){
          return true;
        }
        return isSymmetricChild(root.left,root.right);
    }


    private boolean isSymmetricChild(TreeNode leftTree, TreeNode rightTree){
      if((leftTree != null && rightTree == null) || (leftTree == null && rightTree != null)){
        return false;
      }
      if(leftTree == null && rightTree == null){
        return true;
      }
      if(leftTree.val != rightTree.val){
        return false;
      }
      return isSymmetricChild(leftTree.left,rightTree.right) 
      && isSymmetricChild(leftTree.right,rightTree.left);
    }

二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

描述

编一个程序,读入用户输入的一串先序遍历 字符串,根据此字符串建立一个二叉树(以指针方式存储)。 例如如下的先序遍历字符串: ABC##DE#G##F### 其中"#"表示的是空格,空格字符代表空树。建立起此二叉树以后,再对二叉树进行中序遍历,输出遍历结果。

输入描述:

输入包括1行字符串,长度不超过100。

输出描述:

可能有多组测试数据,对于每组数据, 输出将输入字符串建立二叉树后中序遍历的序列,每个字符后面都有一个空格。 每个输出结果占一行。

示例1

输入:

复制代码
abc##de#g##f###

输出:

复制代码
c b e g d f a 

思路:遍历这个字符串,根据前序遍历来创建二叉树,最后再用中序遍历这棵树

java 复制代码
    public static int i = 0;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str = in.nextLine();
            TreeNode root = createTree(str);
            inorder(root);
        }
    }

    public static TreeNode createTree(String str){
        TreeNode root = null;
        //遍历字符串str
        if(str.charAt(i) != '#'){
            root = new TreeNode(str.charAt(i));
            i++;
            //根据前序遍历创建二叉树
            root.left = createTree(str);
            root.right = createTree(str);
        }else{
            i++;
        }
        //返回root之后才会继续调用createTree来创建左右子树
        return root;
    }

    public static void inorder(TreeNode root){
        if(root == null){
            return ;
        }
        inorder(root.left);
        System.out.print(root.val+" ");
        inorder(root.right);
    }

被static修饰的成员变量只有一份,它是和很多对象共享的

因为本题只有一个测试用例,所以i可以被static修饰。如果有两个测试用例,第一个测试用例执行完假设i停在5的位置,第二个测试用例就只能从5位置开始创建二叉树了

所以后面static成员变量在oj里面要慎用

相关推荐
向阳12188 分钟前
Dubbo负载均衡
java·运维·负载均衡·dubbo
懒惰才能让科技进步12 分钟前
从零学习大模型(十二)-----基于梯度的重要性剪枝(Gradient-based Pruning)
人工智能·深度学习·学习·算法·chatgpt·transformer·剪枝
Gu Gu Study18 分钟前
【用Java学习数据结构系列】泛型上界与通配符上界
java·开发语言
Ni-Guvara25 分钟前
函数对象笔记
c++·算法
WaaTong41 分钟前
《重学Java设计模式》之 原型模式
java·设计模式·原型模式
m0_7430484442 分钟前
初识Java EE和Spring Boot
java·java-ee
AskHarries43 分钟前
Java字节码增强库ByteBuddy
java·后端
泉崎1 小时前
11.7比赛总结
数据结构·算法
你好helloworld1 小时前
滑动窗口最大值
数据结构·算法·leetcode
小灰灰__1 小时前
IDEA加载通义灵码插件及使用指南
java·ide·intellij-idea