二叉树

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

　　1、数组存储方式的分析

　　优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。

　　缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 [示意图]

　　2、链式存储方式的分析

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

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

　　3、树存储方式的分析

　　能提高数据存储，读取的效率,  比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度

二、二叉树的常用术语

1. 节点
2. 根节点
3. 父节点
4. 子节点
5. 叶子节点 (没有子节点的节点)
6. 节点的权(节点值)
7. 路径(从root节点找到该节点的路线)
8. 层
9. 子树
10. 树的高度(最大层数)
11. 森林 :多颗子树构成森林

三、二叉树的概念　

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

　　　　

 

 　　

 

 　　

四、遍历

　　1、前序遍历

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

　　2、中序遍历

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

　　3、后序遍历

//后序遍历
public void postOrder() {
    if(this.left != null) {
        this.left.postOrder();
    }
    if(this.right != null) {
        this.right.postOrder();
    }
    System.out.println(this);
}

五、完整代码

  2 
import org.junit.Test;

/**
 * @author z
 * @createdate 2019-08-15 11:14
 */
public class BinaryTreeTest {
    @Test
    public void test() {
        BinaryTree b = new BinaryTree();
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode n1 = new HeroNode(2, "吴用");
        HeroNode n2 = new HeroNode(3, "玉麒麟");
        HeroNode n3 = new HeroNode(4, "关胜");

        b.setRoot(root);
        root.setLeft(n1);
        root.setRight(n2);
        n1.setLeft(n3);
        b.proOrder();

        b.findproOrder(5);
    }
}

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

    private HeroNode root;

    //前序遍历
    public void proOrder() {
        if (this.root != null) {
            this.root.proOrder();
        } 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 findproOrder(int no) {
        if (this.root != null) {
            HeroNode heroNode = this.root.findproOrder(no);
            if (heroNode != null)
                System.out.println(heroNode);
            else
                System.out.println("未知的英雄编号：" + no);
        } else {
            System.out.println("二叉树为空");
        }
    }

    //中序查找
    public void findinfixOrder(int no) {
        if (this.root != null) {
            HeroNode heroNode = this.root.findinfixOrder(no);
            if (heroNode != null)
                System.out.println(heroNode);
            else
                System.out.println("未知的英雄编号：" + no);
        } else {
            System.out.println("二叉树为空");
        }
    }

    //后序查找
    public void findpostOrder(int no) {
        if (this.root != null) {
            HeroNode heroNode = this.root.findpostOrder(no);
            if (heroNode != null)
                System.out.println(heroNode);
            else
                System.out.println("未知的英雄编号：" + no);
        } else {
            System.out.println("二叉树为空");
        }
    }
}

class HeroNode {
    private int no;
    private String name;
    private HeroNode left; //默认null
    private HeroNode right; //默认null

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                /*", left=" + left +
                ", right=" + 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;
    }

    //编写前序遍历的方法
    public void proOrder() {
        System.out.println(this);
        if (this.left != null) {
            this.left.proOrder();
        }
        if (this.right != null) {
            this.right.proOrder();
        }
    }

    //编写中序遍历的方法
    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 findproOrder(int no) {
        if (this.no == no) {
            return this;
        }
        //1.则判断当前结点的左子节点是否为空，如果不为空，则递归前序查找
        //2.如果左递归前序查找，找到结点，则返回
        HeroNode h = null;
        if (this.left != null) {
            h = this.left.findproOrder(no);
        }
        if (h != null) {
            return h;
        }
        //1.左递归前序查找，找到结点，则返回，否继续判断，
        //2.当前的结点的右子节点是否为空，如果不空，则继续向右递归前序查找
        if (this.right != null) {
            h = this.right.findproOrder(no);
        }
        return h;
    }

    //编写中序查找的方法
    public HeroNode findinfixOrder(int no) {
        HeroNode h = null;
        if (this.left != null) {
            h = this.left.findinfixOrder(no);
        }
        if (h != null) {
            return h;
        }
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            h = this.right.findinfixOrder(no);
        }
        return h;
    }

    //编写后序查找的方法
    public HeroNode findpostOrder(int no) {
        HeroNode h = null;
        if (this.left != null) {
            h = this.left.findpostOrder(no);
        }
        if (h != null) {
            return h;
        }
        if (this.right != null) {
            h = this.right.findpostOrder(no);
        }
        if (h != null) {
            return h;
        }
        if (this.no == no) {
            return this;
        }
        return null;
    }
}