树的前序，后序，中序和层序遍历对比及java代码实现

    1
   / \
  2   3
 / \   \
4   5   6

层序：[1 2 3 4 5 6]
前序：[1 2 4 5 3 6]
中序：[4 2 5 1 3 6]
后序：[4 5 2 6 3 1]

前，中，后序遍历是DFS，可以使用递归的方法，代码除了顺序其他相同：

前序
void dfs(TreeNode root) {
    visit(root);
    dfs(root.left);
    dfs(root.right);
}
中序
void dfs(TreeNode root) {
    dfs(root.left);
    visit(root);
    dfs(root.right);
}
后序
void dfs(TreeNode root) {
    dfs(root.left);
    dfs(root.right);
    visit(root);
}

也可以不使用递归，用Stack来实现：
前序：root->left->right，因此Stack存储根节点后先存储右子树再存储左子树：

public List<Integer> preorderTraversal(TreeNode root) {
    List<Integer> ret = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        if (node == null) continue;
        ret.add(node.val);
        stack.push(node.right); 
        stack.push(node.left);
    }
    return ret;
}

后序：left->right->root，可以看成按照root->right->left前序遍历之后反转的结果，与上述前序的区别是存储根节点之后先存储左子树再存储右子树：

public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> ret = new ArrayList<>();
    Stack<TreeNode> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        if (node == null) continue;
        ret.add(node.val);
        stack.push(node.left);
        stack.push(node.right);
    }
    Collections.reverse(ret);
    return ret;
}

中序：left->root->right，这种情况比前两种复杂一点，root在中间遍历，压入栈中之后不能立刻pop，需要一直遍历到最左边的子树后再pop这个根节点，然后压入右子树，再以右子树为根节点进行中序遍历：

public List<Integer> inorderTraversal(TreeNode root) {
    List<Integer> ret = new ArrayList<>();
    if (root == null) return ret;
    Stack<TreeNode> stack = new Stack<>();
    TreeNode cur = root;
    while (cur != null || !stack.isEmpty()) {
        while (cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
        TreeNode node = stack.pop();
        ret.add(node.val);
        cur = node.right;
    }
    return ret;
}

层序遍历与上述三种有所不同，由于使用的方法是BFS，因此使用的数据结构是Queue，顺序是从上到下，从左到右：

public List<Double> averageOfLevels(TreeNode root) {
    List<Integer> ret = new ArrayList<>();
    if (root == null) return ret;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            ret.add(node.val);
            if (node.left != null) queue.add(node.left);
            if (node.right != null) queue.add(node.right);
    }
    return ret;
}