二叉树基础

为什么需要这种数据结构

1.数组存储方式的分析
优点：通过下标方式访问元素，速度快，对于有序数组，还可以使用二分查找提高检索速度
缺点：如果要检索具体某个值，或者插入值会整体移动，效率较低

说到这个想必大家也一下想到arrarylist了吧，没错它底层存在着自动的数组扩容机制，原理大致如下，详细的可以自己看下源码

1.arrarylist底层维护了数组object类型的数组
2.当创建对象时，如果无法使用的是无参构造器，则初始elementData容量为0(jdk7)是10
3.如果使用的是指定容量capacity的构造器，则初始数组的容量为capacity
4.当添加元素时，先判断是否需要扩容，如果需要扩容，则调用grow方法，否则直接添加元素到合适位置
5.如果使用的是无参构造器，如果第一次添加需要扩容的话，则扩容数组长度为10，如过需要再次扩容的话，则扩容为1.5倍
6.如果使用的是指定容量的capacity的构造器，如果需要扩容也是直接扩容到1.5倍

2.链式存储的分析
优点：在一定程度上对数组存储方式优化：插入一个数值节点，只需要将插入节点，连接到链表中即可
缺点：在进行检索时，效率仍然低下

因为链表的优点，所以链表的创建并不需要连续的内存，它可以利用碎片化的内存，但进行检索时需要从头节点一个个进行遍历，在最差情况下要查找的在链表的末端，效率就相当低下了

3.树存储方式的分析
能提高数据存储、读取的速率，比如利用二叉树排序，既可以保证数据的检索速度，同时也可以保证数据饿插入，删除，修改的速度。

树的常用术语

1.节点 每一个圆圈就是一个结点对象
2.根节点 即A 他前边没有别的节点了
3.父节点 A就是B、C的父节点
4.子节点 B、C就是A的子节点
5.叶子节点 没有子节点的就是叶子节点
6.节点的权 节点的值
7.路径 从根节点找到该节点的路线
8.层 如图，处于同一层面的为一层
9.子树 如图左下
10.树的高度(最大层数)
11.森林 多颗子树就构成森林

二叉树的概念

1.树有很多种，每个节点最多只能有两个节点的一种形式称为二叉树
2.二叉树的子节点分为左节点和右节点
3.如果该二叉树的所有叶子节点都在最后一层，并且节点总数=2^n-1，n为层数。则我们称为满二叉树
4.如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。

二叉树的遍历方式分为3种
前序遍历：先输出父节点，在遍历左子树和右子树
中序遍历：先遍历左子树，在输出父节点，在遍历右子树
后序遍历：先遍历左子树，在遍历右子树，最后输出父节点

看输出父节点的顺序，就确定是前序中序还是后序
遍历步骤的思路分析
1.创建一颗二叉树
2.前序遍历
2.1先输出当前节点
2.2如果左子节点不为空，则递归前序遍历
2.2如果右子节点不为空，则递归继续前序遍历
3.中序遍历
3.1如果当前节点的左子节点不为空，则递归中序遍历
3.2输出当前节点
3.3如果当前节点的右子节点不为空，则递归中序遍历
4.后序遍历
4.1如果当前节点的左子节点不为空，则递归后序遍历
4.2如果当前节点的右子节点不为空，则递归后序遍历
4.3输出当前节点
使用前序、中序、后序查找指定的节点
前序查找思路
1.先判断当前节点的num是否等于要查找的
2.如果是相等，则返回当前节点
3.如果不等，则判断当前节点的左子节点是否为空，如果不为空，则递归前序查找
4.如果左递归找到节点则返回，否则继续判断，当前的节点的右子节点是否为空，如果不空向右递归前序查找
中序查找
1.判断当前节点的左子节点是否为空，如果不为空，则递归中序查找
2.如果找到，则返回，如果没有找到，就和当前节点比较，如果是则返回当前节点，否则继续进行右递归的中序查找
3.如果右递归中序找到就返回，否则返回null
后序查找思路
1.判断当前节点的左子节点是否为空，如果不为空，则递归后序查找
2.如果找到就返回，如果没有找到，就判断当前节点的右子节点是否为空，如果不为空，则右递归后续查找，如果找到就返回
3.和当前节点进行比较，找到就返回，没找到就是null

二叉树删除节点
要求
1.如果删除的节点是叶子节点，则删除该节点
2.如果删除的节点是非叶子节点，则删除该子树
简单的删除，这里没有涉及到往上提子节点的事儿

在这个要求下的思路是
首先先处理
如果树是空树，如果只有一个root节点，则等价将二叉树置空
然后依次判断
1.因为我们的二叉树是单向的，所以我们是判断当前节点的子节点是否需要删除节点，而不能去判断当前的节点是不是需要删除的节点
2.如果当前节点的左子节点不为空，并且左子节点就是要删除的节点，就将this.left置空，同时结束删除任务
3.如果当前节点的右子节点不为空，并且右子节点就是要删除的节点，就将this.right=null，同时结束删除任务
4.如果第二部和第三步没有删除节点，那么就需要向左子树进行递归删除
5.如果左子树没有成功，那么就需要向右子树进行递归删除

这些的代码就统一放在下边啦

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //创建二叉树
        BinaryTree binaryTree = new BinaryTree();
        DataNode root = new DataNode(1, "chen");
        DataNode zhangzhang = new DataNode(2, "zhangzhang");
        DataNode xiang = new DataNode(3, "xiangxiang");
        DataNode feifei = new DataNode(4, "feifei");
        root.setLeft(zhangzhang);
        root.setRight(xiang);
        xiang.setRight(feifei);
        binaryTree.setRoot(root);
        binaryTree.preOrder();
        System.out.println("*************************");
        DataNode dataNode = binaryTree.preOrdersearch(1);
        System.out.println(dataNode);
        System.out.println("**********************");
        DataNode dataNode1 = binaryTree.midOrdersearch(2);
        System.out.println(dataNode1);
        System.out.println("**********************");

        System.out.println("*********************");
        binaryTree.delNode(4);
        DataNode dataNode2 = binaryTree.postOrdersearch(4);
        System.out.println(dataNode2);


    }
}
//定义BinaryTree
class BinaryTree{
    private DataNode root;

    public void setRoot(DataNode root) {
        this.root = root;
    }
    //前序遍历
    public void preOrder(){
        if(this.root!=null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空");
        }
    }
    //中序遍历
    public void midOrder(){
        if(this.root!=null){
            this.root.midOrder();
        }else{
            System.out.println("nullpointexception");
        }
    }
    //后序遍历
    public void postOrder(){
        if(this.root!=null){
            this.root.postOrder();
        }else{
            System.out.println("nullpointexception");
        }
    }
    //前序查找
    public DataNode preOrdersearch(int num){
        if(this.root!=null){
            DataNode dataNode = this.root.preOrdersearch(num);
            return  dataNode;
        }else{
            System.out.println("null ");
            return null;
        }
    }
    //中序查找
    public DataNode midOrdersearch(int num){
        if(this.root!=null){
            DataNode dataNode = this.root.midOrdersearch(num);
            return dataNode;
        }else{
            System.out.println("null");
            return null;
        }
    }
    //后序查找
    public DataNode postOrdersearch(int num){
        if(this.root!=null){
            DataNode dataNode = this.root.postOrdersearch(num);
            return  dataNode;
        }else{
            System.out.println("null");
            return null;
        }
    }
    /**删除节点
     * 如果是叶子节点就直接删除该节点
     *如果不是叶子节点 就直接删除该子树
     */
    public void delNode(int num){
        if(root==null){
            System.out.println("树 为空");
            return;
        }
        if(root.getNum()==num){
           root=null;
           return;
        }
        root.delNode(num);

    }

}
//定义节点
class DataNode{
    private int num;
    private String name;
    private DataNode left;
    private  DataNode right;

    public DataNode(int num, String name) {
        this.num = num;
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

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

    public DataNode getLeft() {
        return left;
    }

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

    public DataNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "DataNode{" +
                "num=" + num +
                ", 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 midOrder(){
        if(this.left!=null){
            this.left.midOrder();
        }
        System.out.println(this);
        if(this.right!=null){
            this.right.midOrder();
        }
    }
    //后序遍历的方法
    public void postOrder(){
        if(this.left!=null){
            this.left.postOrder();
        }
        if(this.right!=null){
            this.right.postOrder();
        }
        System.out.println(this);
    }
    //前序遍历查找
    public DataNode preOrdersearch(int num){
        //比较的次数
        int count=0;
        System.out.println(++count);
    if(this.num==num){
        return this;
    }
    DataNode resNode=null;
    //判断左子节点是否为空
        if(this.left!=null){
            resNode=this.left.preOrdersearch(num);
        }
        if(resNode!=null){
            return resNode;
        }
        if(this.right!=null){
            resNode=this.right.preOrdersearch(num);
        }
        return resNode;


    }
    //中序遍历查找
    public DataNode midOrdersearch(int num){
        DataNode resNode=null;
        if(this.left!=null){
            resNode=this.left.midOrdersearch(num);
        }
        if(resNode!=null){
            return resNode;
        }
        //比较的次数
        int count=0;
        System.out.println(++count);
        if(this.num==num){
            return this;
        }
        if(this.right!=null){
            resNode=this.right.midOrdersearch(num);
        }
        return resNode;
    }
    //后序遍历查找
    public DataNode postOrdersearch(int num){
        DataNode resNode=null;
        if(this.left!=null){
            resNode=this.left.postOrdersearch(num);
        }
        if(resNode!=null){
            return resNode;
        }
        if(this.right!=null){
            resNode=this.right.postOrdersearch(num);
        }
        if(resNode!=null){
            return resNode;
        }
        //比较的次数
        int count=0;
        System.out.println(++count);
        if(this.num==num){
            return this;
        }
        return null;

    }
    /**递归删除节点
     * 如果是叶子节点就删除该节点
     * 如果不是叶子节点就删除该子树
     */
    public void delNode(int num){
        //判断左子节点是否为空，是否权等于我们要删除的
        if(this.left!=null && this.left.num==num){
            this.left=null;
            return;
        }
        //判断右子节点是否为空
        if(this.right!=null && this.right.num==num){
            this.right=null;
            return;
        }
        //向左子树递归
        if(this.left!=null){
            this.left.delNode(num);
        }
        //向右子树递归
        if(this.right!=null){
            this.right.delNode(num);
        }
    }
}