二叉树遍历的三种方式

二叉树遍历有四种方式：前序遍历，中序遍历，后序遍历，层次遍历

这次要说的是前三种，前序遍历的输出顺序是：先输出根结点，然后再输出左孩子结点，最后输出右孩子结点

                                    中序遍历的输出顺序是：先输出左孩子结点，然后输出根节点，最后输出右孩子结点

                                   后序遍历的输出顺序是：先输出左孩子结点，然后输出右孩子结点，最后输出根结点

1.首先建立二叉树的结点

       结点数据结构：

       

public class BinaryTreeNode {       //结点
    private String name;            //结点数据
    private BinaryTreeNode lchild;  //左孩子
    private BinaryTreeNode rchild;  //右孩子

    public String getName() {
        return name;
    }

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

    public BinaryTreeNode getLchild() {
        return lchild;
    }

    public void setLchild(BinaryTreeNode lchild) {
        this.lchild = lchild;
    }

    public BinaryTreeNode getRchild() {
        return rchild;
    }

    public void setRchild(BinaryTreeNode rchild) {
        this.rchild = rchild;
    }
}

2.遍历二叉树的方式

public class OperateBinaryTree {

    //前序遍历      遍历顺序：  根 左  右
    public static void preOrderTraverse(BinaryTreeNode t){
        if(t == null){      //如果为空树
            return;
        }else{
            System.out.println(t.getName());  //输出根节点数据
            preOrderTraverse(t.getLchild());   //遍历左孩子
            preOrderTraverse(t.getRchild());    //遍历右孩子
        }
    }

    //中序遍历      遍历顺序： 左  根  右
    public static void inOrderTraverse(BinaryTreeNode t){
        if(t == null){      //如果为空树
            return;
        }else {
            inOrderTraverse(t.getLchild());         //遍历左孩子
            System.out.println(t.getName());        //输出结点数据
            inOrderTraverse(t.getRchild());         //遍历右孩子
        }
    }

    //后序遍历    遍历顺序：  左  右  根
    public  static void postOrderTraverse(BinaryTreeNode t){
        if(t==null){        //如果为空树
            return;
        }else {
            postOrderTraverse(t.getLchild());       //遍历左孩子
            postOrderTraverse(t.getRchild());       //遍历右孩子
            System.out.println(t.getName());        //输出数据结点
        }
    }

}

3.测试：

public static void main(String[] args) {
    binaryTree();
}

/**
 * 二叉树
 *          0
 *        1   2
 *      3  4 5  6
 *    7  8
 *
 */
private static void binaryTree(){
    BinaryTreeNode n0 = new BinaryTreeNode();
    n0.setName("0号");
    BinaryTreeNode n1 = new BinaryTreeNode();
    n1.setName("1号");
    BinaryTreeNode n2 = new BinaryTreeNode();
    n2.setName("2号");
    BinaryTreeNode n3 = new BinaryTreeNode();
    n3.setName("3号");
    BinaryTreeNode n4 = new BinaryTreeNode();
    n4.setName("4号");
    BinaryTreeNode n5 = new BinaryTreeNode();
    n5.setName("5号");
    BinaryTreeNode n6 = new BinaryTreeNode();
    n6.setName("6号");
    BinaryTreeNode n7 = new BinaryTreeNode();
    n7.setName("7号");
    BinaryTreeNode n8 = new BinaryTreeNode();
    n8.setName("8号");
    n0.setLchild(n1);
    n0.setRchild(n2);
    n1.setLchild(n3);
    n1.setRchild(n4);
    n2.setLchild(n5);
    n2.setRchild(n6);
    n3.setLchild(n7);
    n3.setRchild(n8);

    OperateBinaryTree.preOrderTraverse(n0);         // 0,1,3,7,8,4,2,5,6
    OperateBinaryTree.inOrderTraverse(n0);          //7,3,8,1,4,0,5,2,6
    OperateBinaryTree.postOrderTraverse(n0);        //7,8,3,4,1,5,6,2,0

}