Binary tree pre-order, pre-order and hierarchical traversal

1. The non-recursive realization of the traversal of the preorder in the preorder of the binary tree

Stack (front-middle-back) and queue (layer) implementation

/**
     * 前序遍历（非递归）
     */
    public void preOrder2() {
        preOrder2(root);
        System.out.println();
    }
    private void preOrder2(BiTNode node) {
        Stack<BiTNode> stack = new Stack<BiTNode>();
        while(node!=null||!stack.isEmpty()) {
            while(node!=null) {
                System.out.print(node.data);
                stack.push(node);
                node=node.lchild;
            }
            node=stack.pop().rchild;       
        }
    }
     
     
    /**
     * 中序遍历
     */
    public void inOrder2() {
        inOrder2(root);
        System.out.println();
    }
    private void inOrder2(BiTNode node) {
        Stack<BiTNode> stack = new Stack<BiTNode>();
        while(node!=null||!stack.isEmpty()) {
            while(node!=null) {
                stack.push(node);
                node=node.lchild;
            }                  
            node=stack.pop();
            System.out.print(node.data);
            node=node.rchild;
        }      
    }
     
     
    /**
     * 后序遍历
     */
    public void postOrder2() {
        postOrder2(root);
        System.out.println();
    }
    private void postOrder2(BiTNode node) {
        Stack<BiTNode> stack = new Stack<BiTNode>();
        Stack<Integer> tag = new Stack<Integer>(); //下面这段注释也能实现，与后面未注释部分基本一致。代表了自己的思考过程，就不删除了  
//      while(node!=null||!stack.isEmpty()) {
//          while(node!=null){
//              stack.push(node);
//              tag.push(0);
//              node=node.lchild;
//          }
            //注释中的tag用于标记当前结点是否完成左右子结点遍历（所以用0，1表示）
//          while(!tag.isEmpty()&&tag.peek()==1) {  //栈顶节点的左右子结点已完成遍历
//              System.out.print(stack.pop().data);
//              tag.pop();
//          }
//          if(!tag.isEmpty()) {   //上面和这里的 !flag.isEmpty() 不可省略，不然会出错。
//              tag.pop();
//              tag.push(1);
//              node=stack.peek().rchild;
//          }          
//      }
        /*后序遍历时，分别从左子树和右子树共两次返回根结点（用tag表示次数），
         * 只有从右子树返回时才访问根结点，所以增加一个栈标记到达结点的次序。
         */
        while(node!=null||!stack.isEmpty()) {
            if(node!=null){
                stack.push(node);
                tag.push(1);  //第一次访问
                node=node.lchild;
            }else {
                if(tag.peek()==2) {
                    System.out.print(stack.pop().data);
                    tag.pop();
                }else {
                    tag.pop();
                    tag.push(2); //第二次访问
                    node=stack.peek().rchild;
                }          
            }      
        }
    }
   /*
   *层序遍历
   */
	public void levelOrder() {
	    BiTNode<E> node =root;
	    LinkedList<BiTNode<E>> list = new LinkedList<>();
	    list.add(node);
	    while(!list.isEmpty()) {
	        node=list.poll();
	        System.out.print(node.data);
	        if(node.lchild!=null)
	            list.offer(node.lchild);
	        if(node.rchild!=null)
	            list.offer(node.rchild);
	    }
	}

Recursive implementation of traversal order in preorder of binary tree

/*
 * 前序遍历
 */
public void preOrder() {
    preOrderTraverse(root);
    System.out.println();
} 
private void preOrderTraverse(BiTNode<E> node) {
    if(node==null)
        return;
    System.out.print(node.data);
    preOrderTraverse(node.lchild);
    preOrderTraverse(node.rchild);
}
  
/*
 * 中序遍历
 */
public void inOrder() {
    inOrderTraverse(root);
    System.out.println();
} 
private void inOrderTraverse(BiTNode<E> node) {
    if(node==null)
        return;
    inOrderTraverse(node.lchild);
    System.out.print(node.data);      
    inOrderTraverse(node.rchild);
}
  
/*
 * 后序遍历
 */
public void postOrder() {
    postOrderTraverse(root);
    System.out.println();
} 
private void postOrderTraverse(BiTNode<E> node) {
    if(node==null)
        return;
    postOrderTraverse(node.lchild);           
    postOrderTraverse(node.rchild);
    System.out.print(node.data);
}