数据结构————二叉树基础知识（零基础包会的！）

今天带来数据结构二叉树的知识，保证大家不会离散数学或者没有数据结构基础，也能明明白白的。

一，树

1，树的结构

我们在了解什么是二叉树之前我们先了解下什么是树，树是一种非线性的数据结构，它是由n个节点组成了一个有层次的数，像下面这样的。（罗里吧嗦）

我们学数据结果不用想学离散数学那样什么都要记，了解一些用的多的就行。

我们的树，A是我们的根节点，每个树只有一个，其中，节点之间互相具有父子关系，B是前一个节点的子节点，A是B节点的父亲节点，像H,I这样没有子节点的我们管它叫做叶子节点或者是度为0的节点，B就是度为二的节点，我们有n个节点就有n-1条边，注意每个字节点是不相交的。

树的层数是指当前节点在数的哪一层，树的深度指的是树最深有多少层。

2，树的表示

那么我们怎么用计算机语言来表示二叉树呢，有很多表示法，我们这里使用最常见的表示法

    private class Treenode{
        int val;
        Treenode left;
        Treenode right;
        private Treenode(int val){
            this.val = val;
        }
    }

我们分三个域，val用来存储数据，left，right（为Treenode为树节点引用）用来指向下面的节点。

二，二叉树

1，概念

二叉树跟树有什么区别呢，二叉树是没有超过度为2的节点的树，二叉树是有序的，其中根节点为空也是二叉树。

2，两种特殊的二叉树

（1）满二叉树，当二叉树的节点个数为2的k次方-1(k为层数)时，这是我们称它为满二叉树，除根节点外，每个节点的度都为二。

（2）完全二叉树，完全二叉树是满二叉树的衍生，它是从0到n-1从左到右有序的二叉树，

这样的就是完全二叉树，从左到右，从0到n-1一一对应，

这就不是完全二叉树了，完全二叉树是一个非常非常高效的数据结构。

3，性质

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(n+1)向上取整

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i 的结点有：若i>0，双亲序号：(i-1)/2；i=0，i为根结点编号，无双亲结点。左孩子2*i+1 右孩子 2*i+2。（这块可能会有选择题，不得不记）

可能选择题会用到这些性质

4，四种二叉树遍历方式

先理解，我们马上用代码和图来详细讲解

1，前序变量（先找节点，走左树，再走右树）；

2，中序遍历（先走左树，找中间节点，走右树）；

3，后序遍历（先走左树，再走右树，找中间节点）；

4，层序遍历（从左向右逐个逐层判断）；

所有的遍历都是再递归的基础下的。

这里大家做数据结构练习题的时候，可能会遇到这样的题

12.已知某二叉树的中序遍历序列为JGDHKBAELIMCF，后序遍历序列为JGKHDBLMIEFCA，则其前序遍历序列为（）

这种题有一个快速的方法，是一个b站up主的方法

我们看这个东西，左边是后序遍历，左边可以是前序遍历和后序遍历，下面的只能是中序遍历

我们根据这个格子把每个对应的字母写上去，

根据后序遍历，或者是前序遍历我们都可以确定这道题的头结点为A，A的左右分开，A的左边不能去连A的右边。

我们就能创建一个正确的二叉树，我们再前序遍历它,ABDGJHKCEILMF.

三，用代码实现二叉树

我们就实现下这个树

public class BinaryTree {
    class TreeNode{
        char val;
        TreeNode left;
        TreeNode right;

        public TreeNode(char val) {
            this.val = val;
        }
    }

    /**
     * 创建一棵二叉树 返回这棵树的根节点
     *
     * @return
     */
    public TreeNode createTree() {

    }

    // 前序遍历
    public void preOrder(TreeNode root) {
    }

    // 中序遍历
    void inOrder(TreeNode root) {
    }

    // 后序遍历
    void postOrder(TreeNode root) {
    }

    public static int nodeSize;

    /**
     * 获取树中节点的个数：遍历思路
     */
    void size(TreeNode root) {
    }

    /**
     * 获取节点的个数：子问题的思路
     *
     * @param root
     * @return
     */
    int size2(TreeNode root) {
    }


    /*
     获取叶子节点的个数：遍历思路
     */
    public static int leafSize = 0;

    void getLeafNodeCount1(TreeNode root) {
    }

    /*
     获取叶子节点的个数：子问题
     */
    int getLeafNodeCount2(TreeNode root) {
    }

    /*
    获取第K层节点的个数
     */
    int getKLevelNodeCount(TreeNode root, int k) {
    }

    /*
     获取二叉树的高度
     时间复杂度：O(N)
     */
    int getHeight(TreeNode root) {

    }


    // 检测值为value的元素是否存在
    TreeNode find(TreeNode root, char val) {

        return null;
    }

    //层序遍历
    void levelOrder(TreeNode root) {

    }


    // 判断一棵树是不是完全二叉树
    boolean isCompleteTree(TreeNode root) {
        return true;
    }
}

我们的基本框架，我们一个一个方法实现。

1，创建树

    public TreeNode createTree() {
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');

        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        C.right = F;
        
        return A;
    }

创建我们需要的几个节点，按照图把各个节点连接起来。

2，前序遍历

我们刚才说了前序遍历是先节点，再左树，再右树，这是什么意思呢，我们拿图来举例子。

这个就是大致过程，从A节点开始，遇到节点就打印，这就是我们说的先节点，我们在向左递归，这样我们就又遇到了个节点B，打印B。再向左走，就遇到了节点D，打印D。再向左走，遇到空，走橙色的先返回；回到我们的D节点，再向右递归，又是空，再回到D节点，再返回B节点，再返回A节点，我们这会回到了A节点，再向右递归，走到C节点，打印C，再向右递归，找到F，打印F。再左递归，遇到空，返回，再向右递归，遇到空，返回到F，返回C，返回A，此时中序遍历完成。

照着图和句子进行遍历。

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

3，中序遍历

中序遍历我们也可以使用这个图（先走左树，找中间节点，走右树）

从节点A开始，向左递归走到B，向左递归走到D，向左递归走到null，遇到空节点返回到D，遇到D节点打印D，向右递归遇到空，返回到D，返回到B，遇到B节点，打印B，向右递归到E，向左递归遇到空，返回E节点，打印E，向右递归遇到null，返回到B。返回到A打印节点A，向右递归遇到C，向左递归为空，返回到C，打印C，向右递归遇到F，向左递归遇到null，返回到F，打印F，向右递归，遇到null，返回，一直返回到A节点，中序遍历完成

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

4，后序遍历

后序遍历（先走左树，再走右树，找中间节点）

我们还是从节点开始，向左遍历到达B，向左遍历到达D，向左遍历到达null返回到D，向右遍历到达null返回D，遇到节点D，打印D，返回B，向右遍历，遇到E，向左遍历遇到null，返回到E，向右遍历遇到null，返回到E，打印E，返回到B，打印B，返回A，向右递归到C，向左递归遇到空，返回，向右递归遇到F，向左递归遇到空，返回到F，向右遇到空返回到节点F，打印F，返回到C，打印C，返回到A，打印A；完成后序遍历。

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

三种遍历的结果

可以用刚才那个b站的方法来对一下。

5，获取节点个数，遍历思路

用前序遍历到方法，遇到节点就+1；

public static int nodeSize;

    /**
     * 获取树中节点的个数：遍历思路
     */
    void size(TreeNode root) {
        if(root==null){
            return;
        }
        nodeSize++;
        size(root.left);
        size(root.right);
    }

6，获取节点个数，子问题思路

把每个节点都看做子节点，如果左右都为空返回零，加上自己的节点1，依次递归，最后返回的就是我们要的节点数。

 int size2(TreeNode root) {
        if(root==null){
            return 0;
        }
        return size2(root.left) + size2(root.right) + 1;
    }

7，获取叶子节点个数，遍历思路

从节点开始，先向左遍历，如果当前节点的左右都为空，那么这个节点就为叶子节点，leafSize++，再向右遍历，重复判断的过程，最后leafSize就是我们要的叶子节点数。

    public static int leafSize = 0;
    void getLeafNodeCount1(TreeNode root) {
        if(root==null){
            return;
        }
        if(root.left==null && root.right==null){
            leafSize++;
        }
        getLeafNodeCount1(root.left);
        getLeafNodeCount1(root.right);
    }

8，获取叶子节点，子问题思路

还把递归的时候关注我们的当前节点，如果左右都为空，那么就返回1，说明当前节点就是叶子节点。

 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);
    }

9，获取第k层节点的个数

当我们传来的k为3时,我们只能用k递减的方式来做，代码实际从第一层走向3层，我们用从三层递归到第一层停止，用获取节点的方法看k==1的时候有多少节点，跟获取节点的思路是一样的，只不过多了个限制条件。

 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);
    }

10，获取二叉树的深度

我们还是从节点开始遍历，左边的高度记为left1，右边记为right1，跟找节点个数的思路一样，但是这次我们这返回长的那条分叉，因为深度看的是最深的嘛，我们拿图来举例子

我们从A节点开始，向左走，当前节点不为空，向左走到D，当前节点不为空，向左走，走到null返回，向右走，返回left1和right1都为空，返回right1+1，返回B，B向右走，为空，左大于右，返回左加1，B得到2，返回A，A向左走遇到C，不为空，向左，为空，返回，向右，为空，返回0+1，C为1,C返回到A,A的左大于右，返回左加一，为2+1，为三，所以二叉树深度为3.

 int getHeight(TreeNode root) {
        if (root==null){
            return 0;
        }
        int left1 = getHeight(root.left);
        int right1 = getHeight(root.right);
        return left1>right1?left1+1:right1+1;
    }

11，检测为值value的节点是否存在

我们拿这个图来举例，我们找I节点。

从A开始，value不为I，向左走到B，value不为I，向左走到D，value不为I，向左走到null，为空返回null，ret不接受null，向右走，为null，返回，ret不接受空，返回到B，B的ret也没有得到值，B向右走，走到E，向左走，到H，value不为I，向左走，为null，返回，ret不接收null，向右走位null，ret不接收，返回H，返回到E，ret没有接收到任何值，向右走，value等于I，返回，ret接受到了I，返回，E右边的ret接收到I，返回，B的右边ret接收到I，返回，A的左边接收到ret，返回，找到节点。

    TreeNode find(TreeNode root, char val) {
        if (root==null){
            return null;
        }
        if (root.val==val){
            return root;
        }
        TreeNode ret = find(root.left,val);
        if(ret!=null){
            return ret;
        }
        ret = find(root.right,val);
        if (ret!=null){
            return ret;
        }
        return null;
    }

12，层序遍历

层序遍历就是我们一层一层的数

我们的遍历顺序是ABCDEGHI

我们来实现这个，还是一步一步来，

我们创建一个队列，我们把A放入队列，再把A移除队列给cur，打印cur。

这时cur的值为A节点，把A节点左右的节点依次放到队列中，

再把B给到cur，打印cur，把B的左右的节点放到队列。

再把C给到cur，打印C，把C左右的值给到队列中。

D，E，C左右已经没有节点了，都返回空，我们依次把队列中的节点给cur，再打印cur

    Queue<TreeNode> queue = new LinkedList<>();
    //层序遍历
    void levelOrder(TreeNode root) {
        if (root==null){
            return;
        }

        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);
            }
        }

    }

13，判断一颗树是不是完全二叉树

看着两个图，左边的是完全二叉树，右边的不是，我们怎么用代码判断他们呢，我们要利用层序遍历的方法，null我们也放到队列中。cur得到新节点的的时候我们不打印它，而是判断是否为空，如果为空，就遍历队列，如果都是空那么就是完全二叉树，出现不为空的就不是

    boolean isCompleteTree(TreeNode root) {
        if (root==null){
            return false;
        }
        queue.offer(root);
        while (!queue.isEmpty()){
            TreeNode cur = queue.poll();
            if(cur==null){
                while (!queue.isEmpty()){
                    if (queue.poll()!=null){
                        return false;
                    }
                }
                return true;
            }
            queue.offer(cur.left);
            queue.offer(cur.right);
        }
        return true;
    }