二叉树：前序，后序，中序遍历（递归+非递归）；层次（队列）

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

class Node {
    public int value;
    public Node left;
    public Node right;
    public Node(int v) {
        this.value = v;
        this.left = null;
        this.right = null;
    }
}

public class BinaryTreeTraversal {

    /*
     * 前序遍历主要思想：
     * 从根节点出发，沿着左子树向下搜索，没搜索到直接访问，并将其非空右孩子压栈。
     * 当左子树访问完成，从栈顶弹出右孩子节点，进而遍历该节点的右子树。*/
    /**
     *前序遍历，递归*/
    public static void preOrderRec(Node root) {
        if (root != null) {
            System.out.println(root.value);
            preOrderRec(root.left);
            preOrderRec(root.right);
        }
    }
    /**
     * 前序遍历，非递归*/
    public static void preOrderRec2(Node root) {
        if (root == null)
            return ;
        Stack<Node> s = new Stack<Node>();
        Node temp = root;
        while (!s.empty()) {
            if (temp != null) {
                System.out.println(temp.value);
                s.push(temp);
                temp = temp.left;
            } else {
                temp = s.pop();
                temp = temp.right;
            }
        }
    }

    /**
     * 中序遍历，递归*/
    public static void inOrderRec(Node root) {
        if (root != null) {
            inOrderRec(root.left);
            System.out.println(root.value);
            inOrderRec(root.right);
        }
    }
    /**
     * 中序遍历，非递归*/
    public static void inOrderRec2(Node root) {
        if (root == null)
            return ;
        Stack<Node> s = new Stack<Node>();
        Node temp = root;
        while(! s.empty()) {
            if (temp != null) {
                s.push(temp);
                temp = temp.left;
            } else {
                temp = s.pop();
                System.out.println(temp.value);
                temp = temp.right;
            }
        }
    }

    /**
     * 后序遍历，递归*/
    public static void postOrderRec(Node root) {
        if (root != null) {
            postOrderRec(root.left);
            postOrderRec(root.right);
            System.out.println(root.value);
        }
    }
    /**
     * 后序遍历，非递归
     * 后序遍历需要先处理左右子树，然后处理根（回溯），所以需要一个记录哪些点已经被访问的结构。
     * 此处使用中间栈存储。*/
    public static void postOrderRec2(Node root) {
        Stack<Node> s = new Stack<Node>();
        Stack<Node> o = new Stack<Node>();
        Node temp = root;
        while (! s.empty()) {
            if (temp != null) {
                o.push(temp);   //先压根节点，输出才是最后
                s.push(temp);
                temp = temp.right;
            } else {
                //没有右子节点，替换成根节点的左节点
                temp = s.pop();
                temp = temp.left;
            }
        }
        while (! o.isEmpty()) {
            System.out.println(o.pop().value);
        }
    }

    /**
     * 层次遍历基本思想：
     * 首先将根节点入队，然后每次从队列中取出对首元素进行处理。
     * 每处理一个节点，都是先访问该节点，再按从左到右的顺序把它的孩子节点依次入对。*/
    public static void levelRec(Node root) {
        Queue<Node> q = new LinkedList<>();
        while (! q.isEmpty()) {
            Node temp = q.poll();
            System.out.println(temp.value);
            if (temp.left != null) 
                q.add(temp.left);
            if (temp.right != null)
                q.add(temp.right);
        }
    }
}