Java实现树的遍历

树的遍历总结
整理了最近遇到的关于二叉树的遍历问题，记录如下：
递归：
递归方法比较简单，所以不再赘述。代码如下：
前序:
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Preorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> result;
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
       if (result == null)
       result = new ArrayList<Integer>();
       if (root == null){
           return result;
       }
       result.add(root.val);
      preorderTraversal(root.left);
      preorderTraversal(root.right);
      return result;
    }
}
中序：
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Inorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> result;
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        // write your code here
        if (result == null)
            result= new ArrayList<Integer>();
        if (root == null){
            return result;
        }
        inorderTraversal(root.left);
        result.add(root.val);
        inorderTraversal(root.right);
       return result;
    }
}
后序：
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Postorder in ArrayList which contains node values.
     */
    public  ArrayList<Integer> result;
    public  ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        if (result == null)
        result = new ArrayList<Integer>();
        if (root == null){
            return result;
        }
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        result.add(root.val);
        return result;
    }
}
对于非递归
前序
非递归需要用栈来保存遍历的节点，对于前序遍历来说，是在第一次遇到这个节点的时候就访问它，但是需要把它放进栈里，以便于访问完成之后进一步处理它的左右子树。向左走到底，然后再从栈顶取元素，处理其右子树，如果它没有右子树，则再弹出栈顶~~
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Preorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
       ArrayList<Integer> result = new ArrayList<Integer>();
       if (root == null){
           return result;
       }
       Stack<TreeNode> s = new Stack<TreeNode>();
       while (!s.empty()|| root != null){
           while (root != null){
               result.add(root.val);
               s.push(root);
               root = root.left;
           }
           if (!s.empty()){
               root = s.pop();
               root = root.right;
           }
       }
      return result;
    }
}
中序:
对于中序遍历则同样用栈来保存，但是不是在入栈时就访问，而是在出栈时进行访问。（因为中序遍历要求先访问左子树，由入栈顺序可知，左子树必在根节点之后入栈，所以必先出栈，先访问到。满足要求）
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Inorder in ArrayList which contains node values.
     */
    public ArrayList<Integer> result;
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result= new ArrayList<Integer>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> s = new Stack<TreeNode>();
        while ( !s.empty() || root != null){
            while (root != null){
                s.push(root);
                root = root.left;
            }
            if (!s.empty()){
                root = s.pop();
                result.add(root.val);
                root = root.right;
            }
        }
       return result;
    }
}
后序：
后序遍历比较复杂，在一个节点出栈前，用pre保存上次访问过的节点，如果其右孩子被访问过了或者右孩子为空，则应该出栈，并访问该节点，并将pre置为该节点，root=null是为了出栈下一个元素（因为根都访问完了，该再有新元素出栈了），如果没有，则应该先访问右子树，而非当前元素出栈。
 
public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Postorder in ArrayList which contains node values.
     */
    
    public  ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        if (root == null){
            return result;
        }
        Stack<TreeNode> s = new Stack<TreeNode>();
        TreeNode pre = null;
        while ( !s.empty() || root != null){
            while (root != null){
                s.push(root);
                root = root.left;
            }
            if ( !s.empty()){
                root = s.peek();
            if ( pre == root.right || root.right == null){
                    root = s.pop();
                    result.add(root.val);
                    pre = root;
                    root = null ;
                }
                else{
                    root = root.right;
                }
            }
        }
        return result;
    }
}