java 樹的遍歷(遞歸與非遞歸)

package wangChaoPA實習工做練習.com.leetcode;
import java.util.ArrayList;
import java.util.Stack;
class TreeNode
{
    TreeNode left;
    TreeNode right;
    int val;

    TreeNode(int x)
    {
        val = x;
    }
}

public class TreeTrivel
{
    // 測試
    public static void main(String[] args)
    {
        TreeTrivel aa = new TreeTrivel();
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        TreeNode treeNode4 = new TreeNode(4);
        TreeNode treeNode5 = new TreeNode(5);
        TreeNode treeNode6 = new TreeNode(6);
        TreeNode treeNode7 = new TreeNode(7);
        treeNode1.left = treeNode2;
        treeNode1.right = treeNode3;
        treeNode2.left = treeNode4;
        treeNode2.right = treeNode5;
        treeNode3.left = treeNode6;
        treeNode3.right = treeNode7;
        /*
         * ArrayList<Integer> postorder = aa.postorderTraversal(treeNode1); for
         * (Integer temp : postorder) { System.out.print(temp + " "); }
         * System.out.println();
         */
        /*
         * ArrayList<Integer> preorder = aa.preorderTraversal(treeNode1); for
         * (Integer temp : preorder) { System.out.print(temp + " "); }
         * System.out.println();
         */

        /*
         * ArrayList<Integer> inorder = aa.inorderTraversal(treeNode1); for
         * (Integer temp : inorder) { System.out.print(temp + " "); }
         * System.out.println();
         */

        /*
         * ArrayList<Integer> inorder = aa.inorder(treeNode1); for (Integer temp
         * : inorder) { System.out.print(temp + " "); } System.out.println();
         */
        ArrayList<Integer> postorder = aa.postorder(treeNode1);
        for (Integer temp : postorder)
        {
            System.out.print(temp + " ");
        }
        System.out.println();
    }

    ArrayList<Integer> res = new ArrayList<Integer>();

    /*
     * 遞歸中序遍歷
     */
    public ArrayList<Integer> inorder(TreeNode root)
    {
        if (root == null)
        {
            return this.res;
        }
        inorder1(root);
        return this.res;
    }

    private void inorder1(TreeNode root)
    {
        if (root == null)
        {
            return;
        }
        inorder1(root.left);
        this.res.add(root.val);
        inorder1(root.right);
    }

    /*
     * 非遞歸中序遍歷 最重要的是判斷結點p有沒有做結點,如有則p.left進棧,並使p.left=null,不然將p.val保存到鏈表中,並判斷p.
     * right是否爲null 若不爲null則把p.right進棧
     */
    public ArrayList<Integer> inorderTraversal(TreeNode root)
    {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null)
        {
            return res;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.empty())
        {
            TreeNode temp = stack.peek();
            if (temp.left == null)
            {
                TreeNode p = stack.pop();
                res.add(p.val);
                if (p.right != null)
                {
                    stack.push(temp.right);
                }

            }
            else
            {
                stack.push(temp.left);
                temp.left = null;
            }
        }
        return res;
    }

    /*
     * 遞歸後序遍歷
     */
    public ArrayList<Integer> postorder(TreeNode root)
    {
        if (root == null)
        {
            return this.res;
        }
        postorder1(root);
        return this.res;
    }

    private void postorder1(TreeNode root)
    {
        if (root == null)
        {
            return;
        }
        postorder1(root.left);
        postorder1(root.right);
        this.res.add(root.val);
    }

    /*
     * 非遞歸後序遍歷 思路:要保證根結點在其左孩子和右孩子訪問以後才能訪問,所以對於任一結點p,先將其入棧.
     * 若是p不存在左孩子和右孩子,則可直接訪問;不然將p的右孩子和左孩子依次入棧而後把p的左右孩子結點賦值null,這樣就保證了每次取棧頂的元素的時候
     * 左孩子在右孩子前面被訪問, 左孩子和右孩子都在根結點前面被訪問
     */
    public ArrayList<Integer> postorderTraversal(TreeNode root)
    {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null)
        {
            return res;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty())
        {
            TreeNode temp = stack.peek();
            if (temp.left == null && temp.right == null)
            {
                TreeNode pop = stack.pop();
                res.add(pop.val);
            }
            else
            {
                if (temp.right != null)
                {
                    stack.push(temp.right);
                    temp.right = null;
                }
                if (temp.left != null)
                {
                    stack.push(temp.left);
                    temp.left = null;
                }
            }
        }
        return res;
    }

    /*
     * 遞歸前序遍歷
     */
    public ArrayList<Integer> preorder(TreeNode root)
    {
        if (root == null)
        {
            return this.res;
        }
        preorder1(root);
        return this.res;
    }

    private void preorder1(TreeNode root)
    {
        if (root == null)
        {
            return;
        }
        this.res.add(root.val);
        preorder1(root.left);
        preorder1(root.right);
    }

    // 非遞歸前序遍歷
    /*
     * p.val直接保存到鏈表中,而後判斷p.right是否爲null若不爲null則將p.right進棧 而後判斷
     * p.left是否爲null若不爲null則將p.left進棧
     */
    public ArrayList<Integer> preorderTraversal(TreeNode root)
    {
        ArrayList<Integer> res = new ArrayList<Integer>();
        if (root == null)
        {
            return res;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.empty())
        {
            TreeNode temp = stack.pop();
            res.add(temp.val);

            if (temp.right != null)
            {
                stack.push(temp.right);
            }
            if (temp.left != null)
            {
                stack.push(temp.left);
            }
        }
        return res;
    }
}