二叉树的先序和中序遍历大家都是差不多的，但是后序遍历有很多不同的实现方法，在查了很多资料之后，感觉这一种是比较直观而且很巧妙的利用stack的实现方式，就是有点儿费空间。

构造二叉树

采用二叉链表为二叉树的存储结构，实现基于带空子树的遍历序列构造二叉树的方法

    //基于带空子树的遍历序列构造二叉树
    private int i = 0; //[1]
    private BinaryNode<T> create(T[] prelist){
        BinaryNode<T> p = null;
        if(i<prelist.length){
            T elem = prelist[i];
            i++;
            if(elem!=null){ //不为空即创建叶子节点
                p = new BinaryNode<T>(elem);//创建叶子节点
                p.left = create(prelist);   //创建左子树
                p.right = create(prelist);  //创建右子树
            }
        }
        return p;
    }

注： int i = 0;用于记录已经添加的节点数量，已经添加的节点数量等于preList的长度（即节点的数量）时，到达递归出口。

遍历算法

先序遍历的递归算法

//先序遍历递归算法
public void preorder() {
    preorder(this.root);
    System.out.println();
}

private void preorder(BinaryNode<T> p) {
    if (p != null) {
        System.out.print(p.data.toString() + " ");
        preorder(p.left);
        preorder(p.right);
    }
}

中序遍历的递归算法

public void inorder() {
    inorder(this.root);
    System.out.println();
}

private void inorder(BinaryNode<T> p) {
    if (p != null) {
        inorder(p.left);
        System.out.print(p.data.toString() + " ");
        inorder(p.right);
    }
}

后序遍历的递归算法

//后续遍历递归算法
public void postorder() {
    postorder(this.root);
    System.out.println();
}

private void postorder(BinaryNode<T> p) {
    if (p != null) {
        postorder(p.left);
        postorder(p.right);
        System.out.print(p.data.toString() + " ");
    }
}

先序遍历的递归算法

public void preorderTraverse(){
    System.out.println("先根次序遍历（非递归）：");
    LinkedStack<BinaryNode<T>> stack = new LinkedStack<BinaryNode<T>>();
    BinaryNode<T> p = this.root;
    while(p!=null||!stack.isEmpty()){
        if(p!=null){
            System.out.print(p.data.toString()+" ");
            stack.push(p);
            p = p.left;
        }else{
            System.out.print("^ ");
            p = stack.pop();
            p = p.right;
        }
    }
    System.out.println("^");
}

中序遍历的非递归算法

//非递归算法的中序遍历
public void inorderTraverse(){
    System.out.println("中根次序遍历（非递归）：");
    LinkedStack<BinaryNode<T>> stack = new LinkedStack<BinaryNode<T>>();//创建空栈
    BinaryNode<T> p = this.root;
    while(p!=null||!stack.isEmpty()){//p非空或栈为空
        if(p!=null){
            stack.push(p);//p节点入栈
            p=p.left;//进入左子树
        }else{//p为空栈非空
            System.out.print("^ "); 
            p = stack.pop();//p指向出栈节点
            System.out.print(p.data.toString()+" ");//访问节点
            p=p.right;  //进入右子树
        }
    }
    System.out.println("^");
}

后序遍历的非递归算法

public void postorderTraverse(){
    System.out.println("后根次序遍历（非递归）：");
    LinkedStack<BinaryNode<T>> stack = new LinkedStack<BinaryNode<T>>();
    //待操作栈
    LinkedStack<BinaryNode<T>> output = new LinkedStack<BinaryNode<T>>();
    BinaryNode<T> p = this.root;
    System.out.print("^ ");
    while(p!=null||!stack.isEmpty()){
        if(p!=null){
            stack.push(p);
            output.push(p); //进入待操作栈
            p=p.right; //先进入右子树
        }else{
            output.push(new BinaryNode<T>(null)); //将null入待操作栈
            p = stack.pop();
            p = p.left;
        }
    }
    //依次出栈
    while(!output.isEmpty()){
        BinaryNode<T> node = output.pop();
        if(node.data==null)
            System.out.print("^ ");
        else
            System.out.print(node.data.toString()+" ");
    }
    System.out.println();
}
原文地址：https://blog.csdn.net/apandi_/article/details/52916523