二叉树前序中序后序

二叉树

　　前序遍历：先输出父节点，再遍历左子树和右子树

　　中序遍历：先输出左子树，再遍历父节点，最后为右子树

　　后序遍历：先输出左子树，再遍历右子树，最后为父节点

小结：看输出父节点的顺序，就确定是前序还是中序后序

遍历步骤：

　　1、创建一个二叉树

　　2、前序遍历：

　　　　2.1  先输出当前节点（根节点）

　　　　2.2  如果左子节点不为空，则递归继续前序遍历

　　　　2.3  如果右子节点不为空，则递归继续前序遍历

　　3、 中序遍历：

　　　　3.1  如果当前节点的左子节点不为空，则递归中序遍历

　　　　3.2  输出当前节点

　　　　3.3  如果当前节点的右子节点不为空，则递归中序遍历

　　4、后序遍历：

　　　　4.1  如果当前节点的左字节点不为空，则递归后序遍历

　　　　4.2  如果当前节点的右子节点不为空，则递归后序遍历

　　　　4.3  输出当前节点

public class BinaryTreeDemo {
    public static void main(String[] args) {
        //先需要创建一棵二叉树
        BinaryTree binaryTree = new BinaryTree();
        EmpNode root = new EmpNode(1, "aa");
        EmpNode emp2 = new EmpNode(2, "bb");
        EmpNode emp3 = new EmpNode(3, "cc");
        EmpNode emp4 = new EmpNode(4, "dd");
        EmpNode emp5 = new EmpNode(5, "ee");

        //手动创建二叉树，后面学习递归的方式创建二叉树
        root.setLeft(emp2);
        root.setRight(emp3);
        emp3.setRight(emp4);
        emp3.setLeft(emp5);

        //测试
        System.out.println("前序遍历");
        binaryTree.setRoot(root);
        binaryTree.preOrder();

        System.out.println("中序遍历");
        binaryTree.setRoot(root);
        binaryTree.infixOrder();


        System.out.println("后序遍历");
        binaryTree.setRoot(root);
        binaryTree.postOrder();


    }

}

//定义一个BinaryTree
class BinaryTree{
    private  EmpNode root;
    public void setRoot(EmpNode 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 EmpNode{
    private int no;
    private String name;
    private EmpNode left;//默认为null
    private EmpNode right;//默认为null

    public EmpNode(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 EmpNode getLeft() {
        return left;
    }

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

    public EmpNode getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "EmpNode{" +
                "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();//2,1,3,4
        }
        //输出父节点
        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);
    }
}