【数据结构】二叉树基本操作（孩子兄弟表示法 + Java详解 + 原码）

Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：数据结构

在这里插入图片描述

📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

在这里插入图片描述

系列文章目录

数据结构、LeetCode专栏

文章目录

系列文章目录
前言
一、二叉树的遍历
- 1.前序遍历(使用递归)
- 2.中序遍历(使用递归)
- 3.后序遍历(使用递归)
二、二叉树练习题（选择题）
三、二叉树的基本操作
- 1. 接口
- 2.获取树中节点的个数
- - 2.1使用遍历的思想（前中后序都可以）
  - 2.2使用子问题思想解决
- 3.获取叶子节点的个数
- - 3.1使用遍历的思想（前中后序都可以）
  - 3.2使用子问题思想解决
- 4.获取第K层节点的个数
- 5.获取二叉树的高度
- 6.检测值为value的元素是否存在
- 7.层序遍历
- 8.判断一棵树是不是完全二叉树
四、进行测试
总结

前言

学习二叉树一定要结合图形，要掌握递归的思想，就是将一个大问题划分成相同的小问题

一、二叉树的遍历

学习二叉树结构，最简单的方式就是遍历。所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。

访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加 1)。
遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。

在这里插入图片描述

在遍历二叉树时，如果没有进行某种约定，每个人都按照自己的方式遍历，得出的结果就比较混乱， 如果按照某种规则进行约定，则每个人对于同一棵树的遍历结果肯定是相同的。
如果N代表根节点， L代表根节点的 左子树， R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式：

1.前序遍历(使用递归)

NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。

图中前序遍历为： A B D E H C F G

从根结点开始围着跑，依次写出即可。(这是简单的方法，也是最快的，但还是要看一下下面的详细解释哦)

在这里插入图片描述

详细解释(我称它为"三分法")：先序遍历是先根，再左，后右,像递归一样一层一层拨开，(此处的根结点是每一个结点皆可是根，而不是最顶上的根结点)，如上图；分好根左右后，按我们上面的定义(依次遍历：根结点，左子树，右子树)

根是A(写下来)，再拨左子树，此时左子树可分成图二；
根是B(写下来)，再拨左子树，又拨成图三的样子；
根是D(写下来)，左右子树为空，开始归；
回到B，开始判断B的右子树；以此类推。

注意点：判断递归结束的条件
如果该节点判断为空，就直接返回

if(root == null){
    return ;
}

代码如下（示例）：

// 前序遍历
    public void preOrder(TreeNode root) {
        if (root == null) {
            //空树
            return;
        }
        //先打印根节点
        System.out.print(root.val + " ");
        //遍历左子树
        preOrder(root.left);
        //遍历右子树
        preOrder(root.right);
    }

2.中序遍历(使用递归)

LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。

画图跟前序遍历一样

在这里插入图片描述

代码如下（示例）：

// 中序遍历
    void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val + " ");
        inOrder(root.right);
    }

3.后序遍历(使用递归)

LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。

画图跟前序遍历一样

在这里插入图片描述

代码如下（示例）：

// 后序遍历
    void postOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        inOrder(root.right);
        System.out.print(root.val + " ");
    }

二、二叉树练习题（选择题）

某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为()
```
A: ABDHECFG    
B: ABCDEFGH    
C: HDBEAFCG     
D: HDEBFGCA
```

在这里插入图片描述

2.二叉树的先序遍历和中序遍历如下：先序遍历： EFHIGJK;中序遍历： HFIEJKG.则二叉树根结点为()

A: E          
B: F            
C: G          
D: H

在这里插入图片描述

3.设一课二叉树的中序遍历序列：badce ，后序遍历序列：bdeca ，则二叉树前序遍历序列为() A: adbce B: decab C: debac D: abcde

在这里插入图片描述

4.某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出(同一层从左到右)的序列为() A: FEDCBA B: CBAFED C: DEFCBA D: ABCDEF

在这里插入图片描述

三、二叉树的基本操作

1. 接口

代码如下（示例）：

// 获取树中节点的个数
int size(Node root);

// 获取叶子节点的个数
int getLeafNodeCount(Node root);

// 子问题思路-求叶子结点个数
// 获取第K层节点的个数
int getKLevel

NodeCount(Node root, int k);

// 获取二叉树的高度
int getHeight(Node root);

// 检测值为value的元素是否存在
Node ﬁnd(Node root, int val);

//层序遍历
void levelOrder(Node root);

// 判断一棵树是不是完全二叉树
boolean isCompleteTree(Node root);

2.获取树中节点的个数

2.1使用遍历的思想（前中后序都可以）

这里用前序遍历实现

代码如下（示例）：

//求一棵树中节点的个数
    public static int nodeSize;

    /**
     * 方法一：
     * 可以利用遍历的方式来求
     * 前中后三种遍历方式
     * 以前序遍历为例子
     */
    public void size(TreeNode root) {
        if (root == null) {
            //空树
            return;
        }
        //遇到根节点 ++
        nodeSize++;
        //遍历左子树
        size(root.left);
        //遍历右子树
        size(root.right);
    }

注意：
静态变量的使用：使用了静态变量 nodeSize 来存储节点数量。这意味着每次调用 size(TreeNode root) 都会修改同一个变量的值。如果希望在多次调用中独立计数，可以将 nodeSize 改为实例变量，并在每次调用 size(TreeNode root) 时初始化为 0。

2.2使用子问题思想解决

要求一棵树有多少个结点，该树的节点 = 左子树的节点 + 右子树的节点 + 根节点（根节点为1）

在这里插入图片描述

/**
     * 方法二：
     * 利用子问题进行求解
     * 一棵树的节点 = 左子树的节点 + 右子树的节点 + 根节点
     */
    public int size2(TreeNode root) {
        if (root == null) {
            //空树
            return 0;
        }
        int tmp = size2(root.left) + size2(root.right) + 1;
        return tmp;
    }

3.获取叶子节点的个数

什么情况下是叶子结点？

3.1使用遍历的思想（前中后序都可以）

代码如下（示例）：

//求一棵树的叶子节点
    public static int leafNodeCount;

    /**
     * 方法一
     * 用遍历的方式进行求解
     * 前序遍历
     */
    public void getLeafNodeCount(TreeNode root) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            leafNodeCount++;
        }
        getLeafNodeCount(root.left);
        getLeafNodeCount(root.right);
    }

3.2使用子问题思想解决

代码如下（示例）：

/**
     * 方法二
     * 以子问题的方式进行求解
     * 该树的叶子节点 = 左子树叶子节点 + 右子树叶子节点
     */
    public 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);
    }

4.获取第K层节点的个数

在这里插入图片描述

/**
     * 获取第K层节点的个数
     * 以子问题的思路解决
     */
    public 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);
    }

5.获取二叉树的高度

在这里插入图片描述

代码如下（示例）：

 // 获取二叉树的高度

    /**
     * 取左右子树高度的最大值
     *
     * @param root
     * @return
     */
    public int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return Math.max(leftHeight, rightHeight) + 1;
    }

6.检测值为value的元素是否存在

首先判断根节点是不是我们要找的数据
接着从左子树中查找
最后从右子树中查找

代码如下（示例）：

 // 检测值为value的元素是否存在
    //Node ﬁnd(Node root, int val);
    public TreeNode find(TreeNode root, int val) {
        if (root == null) {
            return null;
        }
        if (root.val == val) {
            return root;
        }
        TreeNode leftVal = find(root.left, val);
        if (leftVal != null) {
            return leftVal;
        }
        TreeNode rightVal = find(root.right, val);
        if (rightVal != null) {
            return rightVal;
        }

        return null;
    }

7.层序遍历

设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

层序遍历（BFS，广度优先搜索）是一种用于图的遍历算法。在这种算法中，首先访问根节点，然后逐层访问其所有邻接节点。这个过程会一直重复，直到没有更多节点可以访问。

在这里插入图片描述

使用队列来辅助实现

/**
     * 层序遍历
     * 从上到下，从左到右
     * 使用队列来完成
     *
     * @param root
     */
    public void levelOrder(TreeNode root) {
        //空树
        if (root == null) {
            return;
        }

        //在这里使用 Queue 队列
        Queue<TreeNode> queue = new LinkedList<>();

        queue.offer(root);

        //结束条件是判断这个队列是否为空
        while (!queue.isEmpty()) {
            //定义一个临时变量
            //存储 弹出队列里面的元素
            TreeNode cur = queue.poll();
            //打印弹出的元素
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }

            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }

8.判断一棵树是不是完全二叉树

从肉眼看，很容易看出来一棵树是否是完全二叉树
如何用代码来实现呢？
这就需要我们来借助层序遍历来实现
还是使用队列（先进先出的思想）

// 判断一棵树是不是完全二叉树
    //借助层序遍历来完成
    public boolean isCompleteTree(TreeNode root) {
        //如果这棵树是空树
        if (root == null) {
            //说明是一棵二叉树
            return true;
        }
        //如果这棵树不为空

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            //把根节点先添加到队列里面去
            //定义一个临时变量存储根节点
            TreeNode cur = queue.poll();
            if (cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            } else {
                break;
            }
        }

        while (!queue.isEmpty()){
            TreeNode cur = queue.poll();
            if (cur != null){
                return false;
            }
        }
        return true;
    }

四、进行测试

public class Test {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        BinaryTree.TreeNode root = binaryTree.createTree();
//        System.out.println(root.val);
        System.out.println("前序遍历：");
        binaryTree.preOrder(root);
        System.out.println();
        System.out.println("===============");
        System.out.println("中序遍历：");
        binaryTree.inOrder(root);
        System.out.println();
        System.out.println("===============");
        System.out.println("后序遍历：");
        binaryTree.postOrder(root);
        System.out.println();
        System.out.println("===============");
        System.out.println("该树节点个数（方法一）：");
        binaryTree.size(root);
        System.out.println(BinaryTree.nodeSize);
        System.out.println("该树节点个数（方法二）：");
        System.out.println(binaryTree.size2(root));

        System.out.println("该树的叶子节点（方法一）：");
        binaryTree.getLeafNodeCount(root);
        System.out.println(BinaryTree.leafNodeCount);

        System.out.println("该树的叶子节点（方法二）：");
        System.out.println(binaryTree.getLeafNodeCount2(root));

        System.out.println("取第K层节点的个数（子问题思路）：");
        System.out.println(binaryTree.getKLevelNodeCount(root,3));

        System.out.println("二叉树的高度（子问题思路）：");
        System.out.println(binaryTree.getHeight(root));

        System.out.println("检测值为value的元素是否存在");
        BinaryTree.TreeNode ret = binaryTree.find(root, 'A');
        System.out.println(ret.val);

        System.out.println("层序遍历：");
        binaryTree.levelOrder(root);
        System.out.println();
        System.out.println("判断一棵树是不是完全二叉树");
        System.out.println(binaryTree.isCompleteTree(root));
    }
}