前中后序遍历的递归与非递归版本

前中后序遍历的递归与非递归版本

  前序遍历 Leetcode 144

  中序遍历 Leetcode 94

  后序遍历 Leetcode 145

解题思路

  前序遍历的顺序是根左右。
  中序遍历的顺序是左根右。
  后序遍历的顺序是左右根，也可以看成根右左的取反，这个是非递归版本的重要思想。

代码

前序遍历

/*
递归
*/
class Solution {
    public void dfs(List<Integer> ans, TreeNode now) {
        if (now == null) return;
        ans.add(now.val);
        dfs(ans, now.left);
        dfs(ans, now.right);
    }

    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        dfs(ans, root);
        return ans;
    }
}

/*
非递归
*/
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) return ans;

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.empty()) {
            TreeNode now = stack.pop();
            ans.add(now.val);
            if (now.right != null) {
                stack.push(now.right);
            }
            if (now.left != null) {
                stack.push(now.left);
            }
        }

        return ans;
    }
}

中序遍历

/*
递归
*/
class Solution {
    public void dfs(List<Integer> ans, TreeNode now) {
        if (now == null) return;
        dfs(ans, now.left);
        ans.add(now.val);
        dfs(ans, now.right);
    }

    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        dfs(ans, root);
        return ans;
    }
}

/*
非递归
*/
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) return ans;

        Stack<TreeNode> stack = new Stack<>();
        TreeNode p = root;
        while (!stack.empty() || p != null) {
            while (p != null) {
                stack.push(p);
                p = p.left;
            }
            TreeNode now = stack.pop();
            ans.add(now.val);
            if (now.right != null) {
                p = now.right;// p表示右子树，如果为null则表示遍历完了
            }
        }

        return ans;
    }
}

后序遍历

/*
递归
*/
class Solution {
    public void dfs(List<Integer> ans, TreeNode now) {
        if (now == null) return;
        dfs(ans, now.left);
        dfs(ans, now.right);
        ans.add(now.val);
    }

    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        dfs(ans, root);
        return ans;
    }
}

/*
非递归
*/
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) return ans;

        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.empty()) {
            TreeNode now = stack.pop();
            ans.add(now.val);
            if (now.left != null) {
                stack.push(now.left);
            }
            if (now.right != null) {
                stack.push(now.right);
            }
        }
        Collections.reverse(ans);

        return ans;
    }
}