二叉树的实现及其相关习题~

果绿森裙@

已于 2022-03-25 21:47:40 修改

阅读量510

点赞数

分类专栏：数据结构文章标签：数据结构 java

于 2022-03-06 00:07:48 首次发布

本文链接：https://blog.csdn.net/qq_57603004/article/details/123303151

版权

本文介绍了二叉树的基本概念，包括节点度和叶节点。详细讲解了如何创建二叉树，以及二叉树的前、中、后序遍历。此外，还提供了多个习题，包括获取节点个数、叶子节点个数、树的层级节点数、高度、查找特定值、判断完全二叉树、子树检测、平衡二叉树判断、对称二叉树检测以及二叉树的层次遍历等，每个习题都给出了详细的解决思路。

摘要由CSDN通过智能技术生成

一、二叉树的相关概念

1、概念

节点的度：一个结点含有子树的个数称为该结点的度如上图：A的度为6

叶子结点或终端结点：度为0的结点称为叶结点；如上图：B、C、H、I...等节点为叶结点

结点的层次 ：从根开始定义起，根为第 1 层，根的子结点为第 2 层，以此类推

树的深度 ：A的深度为1，E为2，J为3，P为4

树的高度 ：最大的深度为高度此树高度为4

2、二叉树的性质

1. 若规定 根结点的层数为 1 ，则一棵 非空二叉树的第 i 层上最多有 $2^{i-1}$ (i>0) 个结点

2. 若规定只有 根结点的二叉树的深度为 1 ，则 深度为 K 的二叉树的最大结点数是 $2^{K}-1$

(k>=0)

3. 对任何一棵二叉树 , 如果其 叶结点个数为 n0, 度为2的非叶结点个数为 n2，则n0=n2+1

4. 具有 n 个结点的完全二叉树的深度 k 为 $log_{2}(n+1)$ 向 上取整

5. 对于具有 n 个结点的完全二叉树 ，如果按照 从上至下从左至右的顺序对所有节点 从0开始编号 ，则对于 序号为 i

的结点有 ：

若 i>0 ， 双亲序号： (i-1)/2 ； i=0 ， i 为根结点编号，无双亲结点 (若从1开始编号则为i/2）

若 2i+1<n ，左孩子序号： 2i+1 ，否则无左孩子

若 2i+2<n ，右孩子序号： 2i+2，否则无右孩子

二、创建一棵二叉树

1、简单创建二叉树

//二叉树的实现
class Node{//创建节点
    public int val;
    public Node left;
    public Node right;
    public Node(int val){
        this.val=val;
    }
}

public class Binarytree {
    public Node root;//二叉树的根节点

    public Node createTree(){//简单方式创建二叉树
        Node A=new Node('A');
        Node B=new Node('B');
        Node C=new Node('C');
        Node D=new Node('D');
        Node E=new Node('E');
        Node F=new Node('F');
        Node G=new Node('G');
        Node H=new Node('H');
        A.left=B;
        A.right=C;
        B.left=D;
        B.right=E;
        C.left=F;
        C.right=G;
        E.right=H;
        return A;//返回根
    }

测试二叉树是否创建成功：

二、二叉树的前、中、后序遍历

1、二叉树的前序遍历

    //没有返回值的二叉树的前序遍历(根->左->右)
    void preOrder(Node root){//递归
        if(root==null){//递归结束条件：当没有节点的时候返回
            return;
        }
        System.out.print(root.val+" ");
        preOrder(root.left);
        preOrder(root.right);
    }



    //有返回值的二叉树的前序遍历
    //(法一：遍历思路，一个节点一个节点去遍历)
    List<Integer> list=new ArrayList<>();//只创建一个list，遍历时只往这一个list里面添加
    public List<Integer> preOrder1(Node root){
        if(root==null){
            return list;
        }
        list.add(root.val);//将根的值添加到list
        preOrder1(root.left);
        preOrder1(root.right);
        return list;
    }



    //（法二：子问题思路，拆分为根，根的左，根的右）
    public List<Integer> preOrder2(Node root){
        List<Integer> list=new ArrayList<>();//每次递归都创建一个list
        if(root==null){
            return list;
        }
        list.add(root.val);
        List<Integer> leftTree=preOrder2(root.left);
        list.addAll(leftTree);//将这次递归的左树都放在list中，方便下次递归创建一个新的list后再将刚刚的左树放入
        List<Integer> rightTree=preOrder2(root.right);
        list.addAll(rightTree);
        return list;

    }

2、二叉树的中序遍历

     //没有返回值的二叉树的中序遍历(左->根->右)
    void inOrder(Node root){
        if(root==null){
            return;
        }
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }



    //有返回值的二叉树的中序遍历(法一：遍历思路)
    List<Integer> list1=new ArrayList<>();
    public List<Integer> inOrder1(Node root){
        if(root==null){
            return list1;
        }
        inOrder1(root.left);
        list1.add(root.val);
        inOrder1(root.right);
        return list1;
    }



    //有返回值的二叉树的中序遍历(法二：子问题思路)
    public List<Integer> inOrder2(Node root){
        List<Integer> list=new ArrayList<>();
        if(root==null){
            return list;
        }
        List<Integer> leftTree=inOrder2(root.left);
        l