二叉树遍历
一、先序遍历和递归实现
1.访问根节点
2.先序遍历其左子树
3.先序遍历其右子树

二、中序遍历和非递归实现
1.中序遍历其左子树
2.访问根节点
3.中序遍历其右子树

三、后序遍历和非递归实现
1.后序遍历其左子树
2.后序遍历其右子树
3.访问根节点

二叉树遍历代码部分：

/**
 * Created by yz on 2018/3/13.
 */
public class MyNode {
    private String value;//节点的业务数据
    private MyNode left; //左子树
    private MyNode right;//右子树

    public MyNode(String value, MyNode left, MyNode right) {
        this.value = value;
        this.left = left;
        this.right = right;
    }

    /**
     * 访问当前节点
     */
    public void visit(){
        System.out.print(value+" ");
    }

    /**
     * 访问当前节点，去往当前节点的左子树
     * @return
     */
    public MyNode getLeft() {
        return left;
    }

    public MyNode getRight() {
        return right;
    }
}


/**
 * Created by yz on 2018/3/13.
 */
public interface VisitAll {
    // 访问树
    void visitTree(MyNode myNode);
}


/**
 * 二叉树遍历 -- 先序遍历和递归实现
 * 1.访问根节点
 * 2.先序遍历其左子树
 * 3.先序遍历其右子树
 * Created by yz on 2018/3/13.
 */
public class PreVisitImpl implements VisitAll{
    public void visitTree(MyNode myNode) {
        if(myNode == null){
            return;
        }
        myNode.visit();
        visitTree(myNode.getLeft());
        visitTree(myNode.getRight());
    }
}


/**
 * 二叉树遍历 -- 中序遍历和非递归实现
 * 1.中序遍历其左子树
 * 2.访问根节点
 * 3.中序遍历其右子树
 * 使用栈集合 Deque<E>
 * Created by yz on 2018/3/13.
 */
public class MidVisitImpl implements VisitAll {
    public void visitTree(MyNode myNode) {
        Deque<MyNode> deque = new ArrayDeque<MyNode>();
        while (myNode !=null || deque.size()>0){
            while (myNode !=null){
                deque.push(myNode);
                myNode = myNode.getLeft();
            }
            if(deque.size()>0){
                myNode = deque.pop();
                myNode.visit();
                myNode = myNode.getRight();
            }
        }
    }
}


/**
 * 二叉树遍历 -- 后序遍历和非递归实现
 * 1.后序遍历其左子树
 * 2.后序遍历其右子树
 * 3.访问根节点
 * 双栈Deque<E>
 * Created by yz on 2018/3/13.
 */
public class PostVisitImpl implements VisitAll {
    public void visitTree(MyNode myNode) {
        Deque<MyNode> deque = new ArrayDeque<MyNode>();
        Deque<MyNode> reverseDeque = new ArrayDeque<MyNode>();
        while (myNode != null || deque.size()>0){
            while (myNode != null){
                deque.push(myNode);
                reverseDeque.push(myNode);
                myNode = myNode.getRight();
            }
            if(deque.size()>0){
                myNode = deque.pop();
                myNode = myNode.getLeft();
            }
        }
        while (reverseDeque.size()>0){
            myNode = reverseDeque.pop();
            myNode.visit();
        }
    }
}


/**
 * Created by yz on 2018/3/13.
 */
public class InitTree {
    public static MyNode init(){
        MyNode h = new MyNode("H",null,null);
        MyNode g = new MyNode("G",null,h);
        MyNode i = new MyNode("I",null,null);
        MyNode c = new MyNode("C",g,i);
        MyNode e = new MyNode("E",null,null);
        MyNode f = new MyNode("F",e,null);
        MyNode d = new MyNode("D",null,null);
        MyNode b = new MyNode("B",d,f);
        MyNode a = new MyNode("A",b,c);
        return a;
    }
}


/**
 * 测试
 * Created by yz on 2018/3/13.
 */
public class BinTree {
    public static void main(String[] args) {
        MyNode rootFact = InitTree.init();
        VisitAll visitAll = new PostVisitImpl();
        visitAll.visitTree(rootFact);
    }
}