尚硅谷数据结构与算法(Java)--21--二叉树

：二叉树

相关术语

1. ①节点：包含一个数据元素及若干指向子树分支的信息 。
2. ②节点的度：一个节点拥有子树的数目称为节点的度   。
3. ③叶子节点：也称为终端节点，没有子树的节点或者度为零的节点 。
4. ④分支节点：也称为非终端节点，度不为零的节点称为非终端节点   。
5. ⑤树的度：树中所有节点的度的最大值   。
6. ⑥节点的层次：从根节点开始，假设根节点为第1层，根节点的子节点为第2层，依此类推，如果某一个节点位于第L层，则其子节点位于第L+1层   。
7. ⑦树的深度：也称为树的高度，树中所有节点的层次最大值称为树的深度   。
8. ⑧有序树：如果树中各棵子树的次序是有先后次序，则称该树为有序树   。
9. ⑨无序树：如果树中各棵子树的次序没有先后次序，则称该树为无序树   。
10. ⑩森林：由m（m≥0）棵互不相交的树构成一片森林。如果把一棵非空的树的根节点删除，则该树就变成了一片森林，森林中的树由原来根节点的各棵子树构成   。

        二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分  。

        二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点   。

1. 前序遍历: 先输出父节点， 再遍历左子树和右子树
2. 中序遍历: 先遍历左子树， 再输出父节点， 再遍历右子树
3. 后序遍历: 先遍历左子树， 再遍历右子树， 最后输出父节点

代码构建的二叉树图示。

package com.atguigu.tree;
 
public class BinaryTreeDemo {
    public static void main(String[] args) {
        //创建一个二叉树
        BinaryTree1 binaryTree = new BinaryTree1();
        //创建需要的结点
        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
 
        //说明，我们先手动创建该二叉树，后面我们学习递归的方式创建二叉树
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        binaryTree.setRoot(root);
 
        System.out.println("前序遍历");
        binaryTree.preOrder();
 
        System.out.println("中序遍历");
        binaryTree.infixOrder();
 
        System.out.println("后序遍历");
        binaryTree.postOrder();
    }
}
 
//定义一个二叉树
class BinaryTree1{
    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("二叉树为空，无法遍历");
        }
    }
}
 
//先创建HeroNode 结点
class HeroNode{
    private int no;
    private String name;
    private HeroNode left; //默认为null
    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);  //先输出父节点
    }
}