二叉树的前中后序递归和非递归

    二叉搜素树的深度遍历一共有三种方式，前序 中序和后续。
    我认为其根本点在于从当前节点进去，而对与进去节点的处理顺序分别就对应了三种遍历方式，一从当前节点进去就对它处理，这就是前序。从当前节点进去先处理其左节点，等左节点处理完了再来处理进入当前节点本身，这就是中序。后续则是处理了当前节点的左节点和右节点再来处理其本身，这就是后序遍历。

---

递归来处理这三种遍历方式来说的话还算比较简单。

public class BinaryTree<E extends Comparable> {
    public class Node {
        public Node left, right;
        public E e;

        public Node(E e) {
            left = null;
            right = null;
            this.e = e;
        }

        public String toString() {
            return e.toString();
        }
    }

    public Node root;
    public int size;

    public BinaryTree() {
        root = null;
        size = 0;
    }

    public void add(E e) {
        root = add(root, e);
    }

    private Node add(Node node, E e) {
        if (node == null) {
            return new Node(e);
        }
        if (e.compareTo(node.e) < 0) {
            return add(node.left, e);
        } else if (e.compareTo(node.e) > 0){
            return add(node.right,e);
        }
        return node;
    }

    public void preOrder(){
        preOrder(root);
    }

    public void preOrder(Node node){
        if (node==null){
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    //中序非递归实现(迭代)
    public void preOrderNr(){
        LinkedList<Node> list = new LinkedList<>();
        list.push(root);
        if (!list.isEmpty()){
            Node cur = list.pop();
            System.out.println(cur.e);
            if (cur.left!=null){
                list.push(cur.left);
            }
            if (cur.right!=null){
                list.push(cur.right);
            }
        }
    }

    public void inOrder(){
        inOrder(root);
    }

    public void inOrder(Node node){
        if (node == null){
            return;
        }
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

    public void inOrderNR(){
        LinkedList<Node> list = new LinkedList<>();
        list.push(root);
        Node p = root.left;
        while(p.left!=null){
            list.push(p);
            p = p.left;
        }
        while(!list.isEmpty()){
            Node cur = list.pop();
            System.out.println(cur.e);
            if (cur.right!=null){
                p = cur.right;
                list.push(p);
                p = p.left;
            }
        }
    }

    public void pastOrder(){
        pastOrder(root);
    }

    private void pastOrder(Node node ){
        if (node == null){
            return;
        }
        pastOrder(node.left);
        pastOrder(node.right);
        System.out.println(node.e);
    }

}