JAVA学习记录（十七）—— 二叉树基础、简单习题

MercuryG

于 2021-01-27 19:24:47 发布

阅读量187

点赞数

本文链接：https://blog.csdn.net/MercuryG/article/details/113119933

版权

树的表示形式

class Node{
    int value;        // 树中存储的数据
    Node firstChild;  // 第一个孩子引用
    Node nextBrother; // 下一个兄弟引用
}

在这里插入图片描述

特殊的二叉树

1、满二叉树：每一个层的结点数都达到最大值，这个二叉树就是满二叉树。个二叉树的层数为K，且节点总数是 $2^k - 1$ ，就是满二叉树。
2、完全二叉树：对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点。

在这里插入图片描述

二叉树的性质

1、若规定根节点的层数为1，则一颗非空二叉树的第i层上最多有 $2^{i-1}(i > 0)$ 个结点
以满二叉树为例，第4层上最多有 $2^3=8$ 个节点
2、若规定只有根节点的二叉树的深度只有1，则深度为K的二叉树的最大节点数（放满）是 $2^k - 1(k>=0)$ 。
以上述满二叉树为例，深度（到根节点的距离）为4的的二叉树的最大节点数为 $2^4-1$ 。
3、队任何一颗二叉树，如果其叶节点个数为n0，度为2的非叶节点个数为n2，则有n0=n2+1。以上述满二叉树为例，第四层上，叶节点个数为8，度为2的非叶结点个数为7（度为2即该结点有两个子结点），即 $8 = 7 + 1$
4、具有n个结点的完全二叉树的深度K为 $log_2(n+1)$ 上取整
以上述满二叉树为例，15个结点，深度 $k = log_2(15+1) = 4$ ，即该二叉树深度为4
5、对于具有n个节点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的节点有：
若 $i > 0$ ，双亲序号： $(i - 1) / 2$ ； $i = 0 ， i$ 为根节点编号，无双亲结点
若 $2 i + 1 < n$ ，左孩子序号： $2 i + 1$ ，否则无左孩子
若 $2 i + 2 < n$ ，右孩子序号： $2 i + 2$ ，否则无右孩子
以完全二叉树为例，已知孩子节点的下表n，推导父亲结点的下标是 $(n - 1) / 2$ ；已知父亲节点下标为n，推导孩子节点，左孩子为 $2 i + 1$ ，有孩子结点 $2 i + 2$ 。

二叉树的存储

顺序存储和类似链表的链式存储
二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式

// 孩子表示法
class Node{
    int val;     // 数据域
    Node left;   // 左孩子的引用
    Node right;  // 右孩子的引用
}

// 孩子双亲表示法
class Node{
    int val;     // 数据域
    Node left;   // 左孩子的引用
    Node right;  // 右孩子的引用
    Node parent; // 当前节点的根节点
}

二叉树的基本操作

1、二叉树的遍历

NLR：前序遍历（Preorder Traversal）——访问根节点—>根的左子树—>根的右子树
LNR：中序遍历（Inorder Traversal）——根的左子树—>根节点—>根的右子树
LRN：后序遍历（Postorder Traversal）——>根的左子树—>根的右子树—>访问根节点
前序遍历： $A B D E H C F G$
中序遍历： $D B E H A F C G$
后序遍历： $D H E B F G C A$

2、二叉树的基本操作

class BTNode{
    public char val;
    public BTNode left;
    public BTNode right;
    
    public BTNode(char val){
        this.val = val;
    }
}
public class BinaryTree{
    
    // 使用穷举方式创建二叉树
    public BTNode creatTree(){
        BTNode A = new BTNode('A');
        BTNode B = new BTNode('B');
        BTNode C = new BTNode('C');
        BTNode D = new BTNode('D');
        BTNode E = new BTNode('E');
        BTNode F = new BTNode('F');
        BTNode G = new BTNode('G');
        BTNode H = new BTNode('H');
        A.left  = B;
        A.right = C;
        B.left  = D;
        B.right = E;
        E.left  = H;
        C.left  = F;
        C.right = G;
        return A;
    }
    
    // 前序遍历
    void preOrderTraversal(BTNode root){
        if(root == null) return;
        System.out.print(root.val);    // 根
        preOrderTraversal(root.left);  // 左
        preOrderTraversal(root.right); // 右
    }
    
    // 中序遍历
    void inOrderTraversal(BTNode root){
        if(root == null) return;
        inOrderTraversal(root.left);   // 左
        System.out.print(root.val);    // 根
        inOrderTraversal(root.right);  // 右
    }
    
    // 后序遍历
    void postOrderTraversal(BTNode root){
        if(root == null) return;
        postOrderTraversal(root.left); // 左
        postOrderTraversal(root.right);// 右
        System.out.print(root.val);    // 根
    }
    
    // 一、遍历-求结点个数
    // 1、遍历思路：递归遍历，每次只要不为空，size++
    static int size = 0;
    void getSize1(BTNode root){
        if(root == null) return;
        size++;
        getSize1(root.left);
        getSize1(root.right);
    }
    // 2、遍历思路：求整棵树的节点个数。左树结点+右树结点+1
    int getSize2(BTNode root){
        if(root == null) return 0;
        return getSize2(root.left) + getSize2(root.right) + 1;
    }
    
    // 二、遍历-求叶子结点个数
    // 1、遍历思路，当root左右结点都为null，即为叶子
    static int leafSize = 0;
    void getLeafSize(BTNode root){
        if(root == null) return;
        if(root.left == null && root.right == null){
            leafSize++;
        }
        getLeafSize(root.left);
        getLeafSize(root.right);
    }
    // 2、子问题思路：左树叶子节点树+右树叶子节点树
    int getLeafSize2(BTNode root){
        if(root == null) return 0;
        if(root.leaf == null && root.right == null){
            return 1;
        }
        return getLeafSize2(root.leaf) + getLeafSize2(root.right);
    }
    
    // 三、遍历-求第K层的节点数
    // 左树的K-1层 + 右树的K-1层
    int getKLevelSize(BTNode root, int k){
        if(root == null || k < 0) return 0;
        if(k == 1 ) return 1;
        return getKLevelSize(root.left, k-1) + getKLevelSize(root, k-1);
    }
    
    // 四、获取二叉树的高度
    // 左树和右树中最大的深度，再加上最上面的根节点
    int getHight(BTNode root){
        if(root == null) return 0;
        return Math.max(getHight(root.left), getHight(root.right)) + 1;
    }
    
    // 五、查找val所在的结点，没有找到返回null
    
    BTNode find(BTNode root, int val){
        if(root == null) return null;
        if(root.val == val) return root;
        BTNode node = find(root.left, val); // 在左树中找到val值
        if(node != null) return node;   // 在左树中找到了
        //没找的的话，再去右树里面找
        return find(root.right, val);
    } 
}

练习

1、二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的前序遍历。
前序：根→左→右

class Solution{  
    public List<Integer> preorderTraversal(TreeNode root){
        List<Integer> list = new Array<>(); 
        if(root != null){
        // 分解子问题，左树和右树
        	list.add(root.val); 
            List<Integer> leftList = preorderTraversal(root.left);
            list.addAll(leftList);
            List<Integer> rightList= preorderTraversal(root.right);
            list.addAll(rightList);
        }
        return list;
    }
}

2、二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的中序遍历。
中序：左→根→右

class Solution {   
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            List<Integer> leftList = inorderTraversal(root.left);
            list.addAll(leftList);
            list.add(root.val);
            List<Integer> rightList = inorderTraversal(root.right);
            list.addAll(rightList);

        }
        return list;
    }
}

3、二叉树的后序遍历

后序遍历：左→根→右

public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        if(root != null){
            List<Integer> listList = postorderTraversal(root.left);
            list.addAll(listList);
            List<Integer> listRight = postorderTraversal(root.right);
            list.addAll(listRight);
            list.add(root.val);
        }
        return list;
    }

上述三种不同遍历方法结果呈现如下：

4、检查两棵树是否相同

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1:
输入:      1         1
          / \       / \
         2   3     2   3
        [1,2,3],   [1,2,3]
输出: true
示例 2:
输入:      1         1
          /           \
         2             2
        [1,2],     [1,null,2]
输出: false
示例 3:
输入:      1         1
          / \       / \
         2   1     1   2
        [1,2,1],   [1,1,2]
输出: false

①对应结点，一个为空一个不为空，则返回false，说明一个此处有结点，一个没有，当然不相同
②如果对应结点都为空，返回true，说明两树在这个块儿都没有结点
③除去上述两个条件后，两树在该位置一定都有结点，判断节点内的值
④通过递归遍历每个结点的左右结点，全部都得返回true

public boolean isSameTree(TreeNode rootOne, TreeNode rootTwo){
    if(rootOne == null && rootTwo != null || rootOne != null && rootTwo == null) return false;
    if(rootOne == null && rootTwo == null) return true;
    if(rootOne.val != rootTwo) return false;  //判断两树当前结点是否相等
    
    return isSameTree(rootOne.left, rootTwo.left) && isSameTree(rootOne.right, rootTwo.right) 
    //节点的左树右树都返回的是true，才会返回true;
}

5、是否是另一个树的子树

给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。
①判断s和t本身是不是两颗相同的树
②如果不是，判断t是不是s的左树
③如果不是，判断t是不是s的右树

// 根据第4题，我们已经有了判断两个数是否相等的函数
public boolean isSameTree(TreeNode rootOne, TreeNode rootTwo){
    if(rootOne == null && rootTwo != null || rootOne != null && rootTwo == null) return false;
    if(rootOne == null && rootTwo == null) return true;
    if(rootOne.val != rootTwo) return false;  //判断两树当前结点是否相等
    
    return isSameTree(rootOne.left, rootTwo.left) && isSameTree(rootOne.right, rootTwo.right) 
}
// 
public boolean isSubtree(TreeNode s, TreeNode t){
    if(s == null || t == null) return false; 
    if(isSameTree(s,t)) return true; // 判断当前位置作为根节点的树是否相同
    // 如果不相同，用t和s的左子树比较
    if(isSubtree(s.left, t)) return true; // 如果相等的话返回true
    // 不相同就比较右子树
    if(isSubtree(s.right, t) return true;
    return false; //都不相同那就false
}

6、二叉树的最大深度

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

public int maxDepth(TreeNode root){
    if(root == null) return 0; // 如果当前结点为null了，返回0，说明是最底下了
    int leftHeight = maxDepth(root.left);   // 看当前左边的高度
    int rightHeight = maxDepth(root.right); // 看当前右边的高度
    return leftHeight > rightHeight ?       // 对于每一个子问题（即每一个结点来说，我们只要最大的，可以代表当前子问题的深度）
           leftHeight + 1 : rightHeight + 1; // 哪个大取哪个，并且加上当前的根节点这1个深度
}

// 可以简化代码如下：
public int maxDepth(TreeNode root) {
    if(root == null) return 0;
    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}

6、平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
方法一：从上往下（时间复杂度：O( $n^2$ )）
①看当前结点的左树和右树的高度差是否<1，小于说明平衡
②看左树是否平衡
③看右树是否平衡

// 用到了上一题的求高度的函数
public int maxDepth(TreeNode root) {
    if(root == null) return 0;
    return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
}
public boolean isBalanced(TreeNode root){
    if(root == null) return true;
    int leftHeight = maxDepth(root.left);   // 左树的高度
    int rightHeight = maxDepth(root.right); // 右树的高度
    return Math.abs(eftHeight - rightHeight) <= 1  // 左树与右树的高度差小于
        && isBalanced(root.left)   // 当前根的左树是平衡的
        && isBalanced(root.right); // 当前根的右树是平衡的
        // 同时满足上述三种情况才会返回true.
}

方法二：从下边往上走，每次返回高度（时间复杂度：O( $n$ )）

public int hight(TreeNode root){
    if(root == null) return 0;
    int leftHight = hight(root.left);
    int rightHight = hight(root.right);
    // 如果 左树的高度 - 右树的高度 < 1 说明此时当前结点的树是平衡的
    // 此时传回去的高度应该是左右高度的最大值+1
    if(leftHight == -1 || rightHight == -1 ||    // 当root左右两端都是返回的-1时，（-1- -1）=0，此时有可能出现不满足的情况[1,2,2,3,null,null,3,4,null,null,4]，应该时false，但是也返回了true
                Math.abs(leftHight-rightHight) > 1) {
            return -1; // 高度是不会有-1的，如果将-1传到下面的函数，就会报false
        }else {
            return Math.max(leftHight,rightHight) + 1;
        }
}
public boolean isBalanced1(TreeNode root) {
        if(hight(root) >= 0) {
            return true;
        }
        return false;
    }

7、判断对称二叉树

给定一个二叉树，检查它是否是镜像对称的。

二叉树 [1,2,2,3,4,4,3] 是对称的。
    1
   / \
  2   2
 / \ / \
3  4 4  3

判断root.left和root.right是否对称
①左树为空右树不为空或左树不为空右树为空，此时肯定不对称，返回false
②判断左树的left和右树的right是否是相同的树
③判断左树的right和右树的left是否是相同的树

public boolean isSymmetricChild(TreeNode leftNode, 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);
}
public boolean isSymmetric(TreeNode root){
    if(root == null){
        return true;
    }
    return  isSymmetric(root.left, root.right);
}

MercuryG

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JAVA学习记录（十七）—— 二叉树基础、简单习题

树的表示形式class Node{ int value; // 树中存储的数据 Node firstChild; // 第一个孩子引用 Node nextBrother; // 下一个兄弟引用}特殊的二叉树1、满二叉树：每一个层的结点数都达到最大值，这个二叉树就是满二叉树。个二叉树的层数为K，且节点总数是2k−12^k - 12k−1，就是满二叉树。2、完全二叉树：对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中
复制链接

扫一扫