非遞歸遍歷二叉樹Java實現

題目：

要求使用非遞歸的方法，中序遍歷二叉樹。

 

解答：

 

前序遍歷

可以使用一個棧來模擬這種操作：

首先將root壓棧；

每次從堆棧中彈出棧頂元素，表示當前訪問的元素，對其進行打印；

依次判斷其右子樹，左子樹是否非空，並進行壓棧操作，至於為什么先壓棧右子樹，因為先壓棧的后彈出，左子樹需要先訪問，因此后壓棧；

中序遍歷和后序遍歷復雜一些。

public class Solution {

    // 非遞歸前序遍歷
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);

        while(!stack.isEmpty()) {
            TreeNode current = stack.pop();
            res.add(current.val);

            if(current.right != null) {
                stack.push(current.right);
            }

            if(current.left != null) {
                stack.push(current.left);
            }
        }

        return res;
    }

    // 非遞歸中序遍歷
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        IF(root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();

        TreeNode p = root;
        while(p != null || !stack.isEmpty()) {
            if(p != null) {
                stack.push(p);
                p = p.left;
            } else {
                p = stack.pop();
                res.add(p.val);
                p = p.right;
            }
        }

        return res;
    }

    // 非遞歸后序遍歷
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) {
            return res;
        }

        Stack<TreeNode> stack = new Stack<>();

        TreeNode p = root;

        // 標記最近出棧的節點，用於判斷是否是p節點的右孩子，如果是的話，就可以訪問p節點
        TreeNode pre = p;

        while(p != null || !stack.isEmpty()) {
            if(p != null) {

                stack.push(p);
                p = p.left;

            } else {
                p = stack.pop();

                if(p.right == null || p.right == pre) {
                    res.add(p.val);
                    pre = cur;
                    p = null;
                } else {
                    stack.push(p);
                    p = p.right;
                    stack.push(p);
                    p = p.left;
                }
            }
        }

        return res;
    }

    // 非遞歸層次遍歷
    public List<Integer> levelTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<>();

        q.add(root);

        while(!queue.isEmpty()) {
            // current node
            TreeNode current = queue.remove();
            res.add(current.val);

            if(current.left != null) {
                queue.add(current.left);
            }

            if(current.right != null) {
                queue.add(current.right);
            }
        }

        return res;
    }

    
}