数据结构与算法学习十六：树的知识、二叉树、二叉树的遍历(前序、中序、后序、层次)、二叉树的查找(前序、中序、后序、层次)、二叉树的删除

一、树的介绍

1.1 为什么需要树这种数据结构

1.1.1 数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。检索、修改速度快。
缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 [示意图]
画出操作示意图：

1.1.2 链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。删除、添加快。

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)
画出操作示意图：

1.1.3 树存储方式的分析

能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。【示意图，后面详细讲】
案例：[7, 3, 10, 1, 5, 9, 12]

1.2 基本介绍

这个的介绍是从百度上拿来的，定义比较简单。

树状图是一种数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

特点：
每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树

1.3 树的常用语

1. 树示意图
   

2. 树的常用术语(结合示意图理解):
   1、节点
   2、根节点
   3、父节点
   4、子节点
   5、叶子节点 (没有子节点的节点)
   6、节点的权(节点值)
   7、路径(从root节点找到该节点的路线)
   8、层
   9、子树
   10、树的高度(最大层数)
   11、森林 :多颗子树构成森林

二、二叉树定义

1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为 二叉树。

2. 二叉树的子节点分为 左节点和右节点。

3. 示意图
   

4. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为 满二叉树。
   

5. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为 完全二叉树。
   

三、二叉树的操作

3.1 二叉树遍历说明

二叉树的遍历，分为 前序遍历、中序遍历、层次遍历。

1. 前序遍历: 先输出父节点，再遍历左子树和右子树
2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
4. 层次遍历：先输出根结点，然后分层次的进行遍历。
   小结: 看输出父节点的顺序，就确定是前序，中序还是后序

3.2 实例

和以往一样，对水浒传英雄进行构建二叉树。

创建8个节点，分别为1 2 3 4 5 6 7 8 。

开始是7个节点，然后后来测试添加，便在6节点左子树挂载 8 结点。
我绘制一下8个节点的二叉树

我们手动遍历一把，然后在与下面代码的输出进行对比。
前序遍历：1 2 4 5 3 6 8 7
中序遍历：4 2 5 1 8 6 3 7
后序遍历：4 5 2 8 6 7 3 1
层次遍历：1 2 3 4 5 6 7 8

事实证明，与下面代码输出一致。

3.3 二叉树遍历

思路分析：

图中文字：
分析二叉树的前序、中序、后序的遍历步骤

1. 创建一颗二叉树

2. 前序遍历
   2.1先输出当前节点（初始的时候是root节点）
   2.2 如果左子节点不为空，则递归继续前序遍历
   2.3 如果右子节点不为空，则递归继续前序遍历

3. 中序遍历
   3.1 如果当前节点的右子节点不为空，则递归中序遍历，
   3.2 输出当前节点
   3.3 如果当前节点的右子节点不为空，则递归中序遍历

4. 后序遍历
   4.1 如果当前节点的左子节点不为空，则递归后序遍历，
   4.2 如果当前节点的右子节点不为空，则递归后序遍历
   4.3 输出当前节点

3.3.1 HeroNode.java 结点

这个类为 节点类。对英雄构建成结点实体类。

在这里面编写 前序、中序、后序遍历的底层方法。注释比较清晰。

package com.feng.ch12_tree.t1_binarytree;

/*
 * 创建 HeroNode 结点
 *
 * 1、数据域 包含 编号 和 姓名
 * 2、指针域包括 左子结点 和 右子结点
 * */
public class HeroNode {
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    // 编写前序遍历的方法
    public void preOrder() {
        System.out.println(this);// 先输出父结点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    // 中序遍历
    public void infixOrder() {
        // 递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出父结点
        System.out.println(this);
        // 递归向右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    // 后序遍历
    public void postOrder() {
        // 递归向遍历
        if (this.left != null) {
            this.left.postOrder();
        }
        // 递归向右子树中序遍历
        if (this.right != null) {
            this.right.postOrder();
        }
        // 输出父结点
        System.out.println(this);
    }
}

3.3.2 BinaryTree.java 二叉树

创建的二叉树，在这里 调用 HeroNode 结点类的 方法，实现二叉树的各种操作，前序、中序、后序的操作。

package com.feng.ch12_tree.t1_binarytree;

import java.util.LinkedList;

/*
 * 定义BinaryTree 二叉树
 * */
class BinaryTree {
    private HeroNode root;

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    // 前序遍历
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 中序遍历
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    // 后序遍历
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /*
     * 层次遍历
     * */
    public void middleOrder() {
        if (this.root != null) {
            LinkedList<HeroNode> queue = new LinkedList();
            queue.add(root);
            HeroNode current = null;

            while (!queue.isEmpty()) {
                current = queue.poll();//出队队头元素并访问
                System.out.println(current);
                if (current.getLeft() != null) {//如果当前节点的左节点不为空入队
                    queue.offer(current.getLeft());
                }
                if (current.getRight() != null) {//如果当前节点的右节点不为空，把右节点入队
                    queue.offer(current.getRight());
                }
            }
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }
}

3.3.3 T1_BinaryTreeMain.java 测试类

测试类，对前序中序后序，进行测试。打印输出，
构建二叉树时，是手动添加。这里主要测试二叉树的前序、中序、后序的遍历

public class T1_BinaryTreeMain {

    public static void main(String[] args) {
        // 先需要创建一颗二叉树
        BinaryTree binaryTree = new BinaryTree();
        // 创建需要的节点

        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "武松");
        HeroNode node6 = new HeroNode(6, "武大郎");
        HeroNode node7 = new HeroNode(7, "李逵");

        /*
         * 说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
         * */
        binaryTree.setRoot(root);
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);
        node3.setRight(node7);

        /*
         * 测试 二叉树 的遍历
         * */
        System.out.println("前序遍历："); // 输出 1 2 4 5 3 6 7
        binaryTree.preOrder();
        System.out.println();

        System.out.println("中序遍历："); // 输出 4 2 5 1 6 3 7
        binaryTree.infixOrder();
        System.out.println();

        System.out.println("后序遍历："); // 输出 4 5 2 6 7 3 1
        binaryTree.postOrder();
        System.out.println();

        System.out.println("层次遍历："); // 输出 1 2 3 4 5 6 7
        binaryTree.middleOrder();
        System.out.println();

        /*
         * 新添加一个节点
         * */
        HeroNode node8 = new HeroNode(8, "关胜");
        node6.setLeft(node8);

        /*
         * 测试 新增加结点 后的遍历
         * */
        System.out.println("添加新节点后的 前序遍历："); // 输出  1 2 3 5 4
        binaryTree.preOrder();
        System.out.println();

        System.out.println("添加新节点后的 中序遍历："); // 输出 2 1 5 3 4
        binaryTree.infixOrder();
        System.out.println();

        System.out.println("添加新节点后的 后序遍历："); // 输出 2 5 4 3 1
        binaryTree.postOrder();
        System.out.println();

        System.out.println("添加新节点后的 层次遍历："); // 输出 2 5 4 3 1
        binaryTree.middleOrder();
        System.out.println();

     }
}

3.3.4 测试结果

这里截图的为测试中添加节点后的遍历：

3.4 二叉树的查找

• 要求

1. 请编写前序查找，中序查找和后序查找的方法。
2. 并分别使用 三种查找方式 ，查找 heroNO = 5 的节点
3. 并分析各种查找方式，分别比较了多少次

• 二叉树的查找也分为前序查找、中序查找、后序查找。
  层次查找直接在二叉树类 BinaryTree.java 中编写。

• 思路分析图解
  
  图中文字如下：
  使用前序，中序，后序的方式来查询指定的结点

前序查找思路

1. 先判断当前节点的 no 是否等于要查找的no
2. 如果是相等，则返回当前结点
3. 如果不等，则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
4. 如果左递归前序查找，找到节点，则返回，否则继续判断 当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找。

中序查找思路

1. 判断当前节点的左子结点是否为空，如果不为空，则递归中序查找
2. 如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点，否则继续进行右递归中序查找
3. 如果右递归中序查找，找到就返回，否则返回null

后序查找思路

1. 判断当前节点的左子结点是否为空，如果不为空，则递归后序查找
2. 如果找到，则返回，如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则有递归进行后续查找，如果找到，就返回
3. 如果左右节点都没有找到，就和当前节点进行比较，如果是则返回，否则返回 null

3.4.1 HeroNode.java 节点类

在这里进行编写底层查找的方法。
包括前序查找、中序查找、后序查找

    /*
     *前序遍历查找
     * @param no 查找 no
     * @return 如果找到就返回该 Node，如果没有找到就返回 null
     * */
    public HeroNode preOrderSearch(int no) {
        System.out.println("进入前序遍历查找~~");
        // 比较当前节点是不是
        if (this.no == no) {
            return this;
        }
        /*
         * 1、则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
         * 2、如果左递归前序查找，找到节点，则返回
         * */
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        // 1、左递归前序查找，找到节点，则返回，否则继续判断
        // 2、当前节点的右子节点是否为空，如果不为空，则继续向右递归前序查找。
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }

    /*
     * 中序遍历查找
     * */
    public HeroNode infixOrderSearch(int no) {
        //1、判断当前节点的左子结点是否为空，如果不为空，则递归中序查找
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入中序遍历查找~~");
        // 2、如果找到，则返回，如果没有找到，就和当前结点比较，如果是则返回当前结点，
        if (this.no == no) {
            return this;
        }

        // 3、否则继续进行右递归中序查找
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    /*
     * 后序遍历查找
     * */
    public HeroNode postOrderSearch(int no) {
        //1、判断当前节点的左子结点是否为空，如果不为空，则递归后序查找,如果找到，则返回，
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }

        // 2、如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则有递归进行后续查找，如果找到，就返回
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("进入后序遍历查找");
        // 3、如果左右节点都没有找到，就和当前节点进行比较，如果是则返回，否则返回 null
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

3.4.2 BinaryTree.java 二叉树

这里是二叉树类，对 结点类中进行包装。

    /*
     * 前序遍历查找
     * */
    public HeroNode preOrderSearch(int no) {
        if (root != null) {
            return root.preOrderSearch(no);
        } else {
            return null;
        }
    }

    /*
     * 中序遍历查找
     * */
    public HeroNode infixOrderSearch(int no) {
        if (root != null) {
            return root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    /*
     * 后序遍历查找
     * */
    public HeroNode postOrderSearch(int no) {
        if (root != null) {
            return root.postOrderSearch(no);
        } else {
            return null;
        }
    }

    /*
     * 层次遍历查找
     * */
    public HeroNode middleOrderSearch(int no) {
        if (root != null) {
            LinkedList<HeroNode> queue = new LinkedList();
            queue.add(root);
            HeroNode current = null;
            HeroNode result = null;

            while (!queue.isEmpty()) {
                current = queue.poll();//出队队头元素并访问
                if (no == current.getNo()){
                    result = current;
                    break;
                }
                if (current.getLeft() != null) {//如果当前节点的左节点不为空入队
                    queue.offer(current.getLeft());
                }
                if (current.getRight() != null) {//如果当前节点的右节点不为空，把右节点入队
                    queue.offer(current.getRight());
                }
            }
            return result;
        } else {
            return null;
        }
    }

3.4.3 T1_BinaryTreeMain.java 测试类

在上面的测试类，后面写

/*
  * 测试二叉树的 查找
  * */
 //  递归4次
 System.out.println("二叉树的 前序遍历查找");
 HeroNode heroNode = binaryTree.preOrderSearch(5);
 if (null == heroNode) {
     System.out.printf("没有找到 no = %d 的英雄", 5);
 } else {
     System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode.getNo(), heroNode.getName());
 }
 System.out.println();

 // 递归 3次
 System.out.println("二叉树的 中序遍历查找");
 HeroNode heroNode1 = binaryTree.infixOrderSearch(5);
 if (null == heroNode1) {
     System.out.printf("没有找到 no = %d 的英雄", 5);
 } else {
     System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode1.getNo(), heroNode1.getName());
 }
 System.out.println();

 // 递归 2次
 System.out.println("二叉树的 后序遍历查找");
 HeroNode heroNode2 = binaryTree.postOrderSearch(5);
 if (null == heroNode2) {
     System.out.printf("没有找到 no = %d 的英雄\n", 5);
 } else {
     System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode2.getNo(), heroNode2.getName());
 }
 System.out.println();

 System.out.println("二叉树的 层次遍历查找");
 HeroNode heroNode3 = binaryTree.middleOrderSearch(4);
 if (null == heroNode3) {
     System.out.printf("没有找到 no = %d 的英雄\n", 5);
 } else {
     System.out.printf("找到了， 信息为 no= %d name=%s \n", heroNode3.getNo(), heroNode3.getName());
 }
 System.out.println();

3.4.4 测试结果

3.5 二叉树的删除

• 要求

1. 如果删除的节点是叶子节点，则删除该节点
2. 如果删除的节点是非叶子节点，则删除该子树.
3. 测试，删除掉 5号叶子节点 和 3号子树.

• 完成删除思路分析：
  
  图中文字：
  完成删除结点的操作
  规定：
  1、如果删除的结点是叶子节点，则删除该节点
  2、如果删除的结点是非叶子节点，则删除该子树
  思路：
  首先先处理：考虑如果树是空树root，如果只有一个root结点，则等价将二叉树置空。
  然后进行下面步骤
  1、因为我们的二叉树是单向的，所以 我们是判断当前节点的子节点是否需要删除节点，而不能取判断当前这个结点是不是需要删除结点。
  2、如果当前节点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null即可；并且就返回(结束递归删除)
  3、如果当前结点的右子节点不为空，并且左子结点就是要删除结点，就将 this.right = null即可；并且就返回(结束递归删除)
  4、如果第2步和第3步没有删除结点，那么我们就需要向左子树进行递归删除
  5、如果第4步也没有删除结点，则应当向右子树进行递归删除。

3.4.1 HeroNode.java 节点类

删除结点时，需要考虑两种情况。
第一种：如果删除的结点是叶子节点，则删除该叶子节点
第二种：如果删除的结点是非叶子节点，则删除该子树

/*
 * 递归删除结点
 * 1、如果删除的结点是叶子节点，则删除该叶子节点
 * 2、如果删除的结点是非叶子节点，则删除该子树
 * 首先先处理：考虑如果树是空树root，如果只有一个root结点，则等价将二叉树置空。 这一部分放在上一层处理
 * */
public void deleteNode(int no) {
    // 第二第三步 为递归的 结束条件
    /*
     * 1、因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能取判断当前这个结点是不是需要删除结点。
     * 2、如果当前节点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null 即可；并且就返回(结束递归删除)
     * 3、如果当前结点的右子节点不为空，并且左子结点就是要删除结点，就将 this.right = null 即可；并且就返回(结束递归删除)
     * 4、如果第2步和第3步没有删除结点，那么我们就需要向左子树进行递归删除
     * 5、如果第4步也没有删除结点，则应当向右子树进行递归删除。
     * */
    // 2、如果当前节点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null 即可；并且就返回(结束递归删除)
    if (this.left != null && this.left.no == no) {
        this.left = null;
        return;
    }

    //3、如果当前结点的右子节点不为空，并且左子结点就是要删除结点，就将 this.right = null 即可；并且就返回(结束递归删除)
    if (this.right != null && this.right.no == no) {
        this.right = null;
        return;
    }
    // 4、如果第2步和第3步没有删除结点，那么我们就需要向左子树进行递归删除
    if (this.left != null) {
        this.left.deleteNode(no);
    }
    //5、如果第4步也没有删除结点，则应当向右子树进行递归删除。
    if (this.right != null) {
        this.right.deleteNode(no);
    }
}

3.5.2 BinaryTree.java 二叉树

/*
 * 递归删除结点
 * */
public void deleteNode(int no) {
    if (root != null) {
        //  如果只有一个节点，这里立即判断root 是不是就是要删除结点
        if (root.getNo() == no) {
            root = null;
        } else {
            root.deleteNode(no);
        }
    } else {
        System.out.println("空树，不能删除~~");
    }
}

3.5.3 T1_BinaryTreeMain.java 测试类

/*
 * 测试删除结点
 * */
System.out.println("删除前，前序遍历");
binaryTree.preOrder(); // 1 2 3 5 4


//binaryTree.deleteNode(5);
binaryTree.deleteNode(3);
System.out.println("删除后，前序遍历");
binaryTree.preOrder(); // 1 2 3 4 // 1 2

3.5.4 测试结果