第十章：树结构的基础部分

10.1二叉树

二叉树是一种数据结构，二叉树与数组、链表的比较：
1、 数组存储方式的分析
优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度
缺点：如果要检索具体某个值，或者插入某个值(按一定顺序)会整体移动，效率较低
【总结：数组便于查询，不适于插入】
2、 链式存储方式的分析
优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好)
缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历)
【总结：链表便于插入与删除，不适于遍历】
3、 树存储方式的分析
能提高数据存储，读取的效率, 比如利用二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度
【总结：二叉树即便于查询又便于插入删除等】

树的示意图：

树的一些常用术语：
1、 节点、根节点（root节点）、父节点、子节点；
2、 叶子节点（没有子节点的节点）
3、 节点的权（节点值）；
4、 路径：从root节点找到该节点的路径；
5、 层；
6、 子树；
7、 树的高度：最大层数；
8、 森林：多棵子树构成森林

二叉树的概念
1、 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树
2、 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层 数，则我们称为满二叉树
3、 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树
【满二叉树和完全二叉树的总结：所有的父节点都是满的；完全二叉树是满二叉树的一棵子树】

二叉树遍历的说明：
1、 前序遍历: 先输出父节点，再遍历左子树和右子树
2、 中序遍历：先遍历左子树，再输出父节点，再遍历右子树
3、 后序遍历：: 先遍历左子树，再遍历右子树，最后输父节点
【总结：看输出父节点的顺序，就确定是前序，中序还是后序遍历】

package com.atguigu09.tree;

import java.util.Scanner;

/**
 * @author peng
 * @date 2021/11/25 - 10:48
 * <p>
 * 实现二叉树
 * 步骤：
 * 1、创建英雄节点
 * 2、在节点中定义三种遍历的方法
 * 3、创建二叉树，并在二叉树中调用三种遍历的方法
 * 4、在主方法中调用二叉树中的方法
 */
public class BinaryTreeDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //创建二叉树
        BinaryTree binaryTree = new BinaryTree();

        //定义节点
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");

        //手工创建二叉树
        binaryTree.setRoot(root);
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);

        //前序遍历
        System.out.println("二叉树前序遍历：");
        binaryTree.binaryTreePreOrder();

        //中序遍历
        System.out.println("二叉树中序遍历:");
        binaryTree.binaryTreeInfixOrder();

        //后序遍历
        System.out.println("二叉树后序遍历：");
        binaryTree.binaryTreePostOrder();

        //前序遍历方式查找
        System.out.println("前序遍历方式进行查找：");
        HeroNode resNode = binaryTree.binaryTreePreOrderSearch(1);
        System.out.println(resNode);

        //中序遍历方式查找
        System.out.println("中序遍历方式进行查找：");
        resNode = binaryTree.binaryTreeInfixSearch(4);
        System.out.println(resNode);

        //后序遍历方式查找
        System.out.println("后序遍历方式进行查找：");
        resNode = binaryTree.binaryTreePreOrderSearch(3);
        System.out.println(resNode);

        //删除指定序号的节点
        System.out.println("请输入要删除节点的编号：");
        int deleteNo = scanner.nextInt();
        binaryTree.binaryTreeDelete(deleteNo);
        binaryTree.binaryTreePreOrder();
    }
}

/**
 * 创建二叉树
 */
class BinaryTree {
    private HeroNode root;//定义一个根节点

    //为根节点提供set方法
    public void setRoot(HeroNode root) {
        this.root = root;
    }

    /**
     * 实现二叉树前序遍历
     */
    public void binaryTreePreOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("当前二叉树是空的，无法进行前序遍历！");
        }
    }

    /**
     * 实现二叉树中序遍历
     */
    public void binaryTreeInfixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("当前二叉树为空，无法进行中序遍历！");
        }
    }

    /**
     * 实现二叉树后序遍历
     */
    public void binaryTreePostOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("当前二叉树为空，无法进行后序遍历！");
        }
    }

    /**
     * 实现二叉树的前序遍历查找
     */
    public HeroNode binaryTreePreOrderSearch(int no) {
        if (this.root != null) {
            return this.root.preOrderSearch(no);
        } else {
            System.out.println("当前二叉树为空，不能进行前序遍历查找！");
        }
        return null;
    }

    /**
     * 实现二叉树中序遍历查找
     */
    public HeroNode binaryTreeInfixSearch(int no) {
        if (this.root != null) {
            return this.root.infixOrderSearch(no);
        } else {
            System.out.println("当前二叉树为空，不能进行中序遍历！");
        }
        return null;
    }

    /**
     * 实现二叉树后序遍历查找
     */
    public HeroNode binarySearchPostSearch(int no) {
        if (this.root != null) {
            return this.root.postOrderSearch(no);
        } else {
            System.out.println("当前二叉树为空，不能进行中序遍历查找！");
        }
        return null;
    }

    /**
     * 实现二叉树删除指定的节点
     */
    public void binaryTreeDelete(int no) {
        //注意：this.root和root在这里是一样的，写哪个都行
        if (root != null) {
            if (root.getNo() == no) {
                //如果删除的是根节点，那么应该把整一棵树都置为空
                root = null;
                return;
            }
            root.delete(no);
        } else {
            System.out.println("当前二叉树为空， 不能进行删除操作！");
        }
    }
}


/**
 * 创建节点
 */
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;
    }

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

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

    /**
     * 节点前序遍历的方法
     */
    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);
    }

    /**
     * 前序遍历查找算法
     */
    public HeroNode preOrderSearch(int no) {
        //首先判断是否是根节点
        if (this.no == no) {
            return this;
        }
        HeroNode resNode = null;
        //如果不是根节点，那么就往左子树查找
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {
            //因为这棵二叉树不是二叉排序树，因此有可能存在相同的数据，因此我们只要返回找到的第一个数据即可
            return resNode;
        }
        //如果左子树没找到，继续在右子树中寻找
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }

        //如果最后都没找到，则返回null
        return resNode;
    }

    /**
     * 中序遍历查找
     */
    public HeroNode infixOrderSearch(int no) {
        HeroNode resNode = null;
        //首先判断左子树是否为空，在左子树中查找
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            //因为这棵二叉树不是二叉排序树，因此有可能存在相同的数据，因此我们只要返回找到的第一个数据即可
            return resNode;
        }
        //如果左子树没找到，再判断根节点
        if (this.no == no) {
            return this;
        }
        //如果都没找到，那么就在右子树中查找
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    /**
     * 后序遍历查找
     */
    public HeroNode postOrderSearch(int no) {
        HeroNode resNode = null;
        //首先判断左子树是否为空
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {
            //因为这棵二叉树不是二叉排序树，因此有可能存在相同的数据，因此我们只要返回找到的第一个数据即可
            return resNode;
        }
        //如果左子树没找到，继续寻找右子树
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            //因为这棵二叉树不是二叉排序树，因此有可能存在相同的数据，因此我们只要返回找到的第一个数据即可
            return resNode;
        }
        //最后判断根节点
        if (this.no == no) {
            return this;
        }
        return resNode;
    }

    /**
     * 递归删除指定的节点，删除节点的规则：
     * 1、如果删除的节点是叶子节点，那么就直接删除；
     * 2、如果删除的不是叶子节点，那就删除对应的子树
     */
    public void delete(int no) {
        //先判断删除的是否是左子节点
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        //判断删除的节点是否是右子节点
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        //如果不满足以上的情况，向左子树递归删除
        if (this.left != null) {
            this.left.delete(no);
        }
        //如果不满足以上的情况，向右子树进行递归删除
        if (this.right != null) {
            this.right.delete(no);
        }
    }
}