Binary Tree Xorder Traversal

二叉树的前序, 中序, 后序, 层序遍历方法

 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }

解题思路

1.语法：

与二叉树相关的问题， 不要想得太复杂，数据结构抽象如下

            根节点
            /   \
        左子树   右子树

而左子树和右子树又可以看成和上面相同的数据结构，

即树具有递归性质的数据结构， 解决树的问题时，递归首选。

2.非递归解题思路：

二叉树除了根节点，所有的叶子节点都可以看成左节点或者右节点

关于子树根节点的处理很微妙，因为子树的根节点同样是上级子树的左儿子或者右儿子, 所以不用单独处理，只需要处理左右儿子节点就能搞定一棵树。如果根节点需要单独处理，只有一个也很容易处理。

先序遍历

先序遍历： 根-左-右, p.val 处理要在 p.left 和 p.right 处理之前

前序遍历中, 每个节点都是在它的子树之前处理. 然而, 尽管每个节点在其子树之前进行了处理, 但在向下移动的过程中还是需要保留一些信息. 当左子树遍历完成之后, 必须返回其右子树来继续遍历. 为了能够在左子树遍历完成后能移动到右子树, 必须保留根节点信息. 能够实现该信息存储的显然是栈, 它能以逆序获取信息并返回到右子树.

迭代解法

解法1

不推荐下面的解法, 以后都要使用解法二的思想.

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        TreeNode p = root;
        List<Integer> ans = new LinkedList<>();

        if (p == null) return ans;
        Stack<TreeNode> stack = new Stack<>();

        // 由于在下面区分树的左右儿子节点的方式处理所有节点, 所以根节点我们额外处理, 很麻烦
        stack.push(p);
        ans.add(p.val);

        // 这种写法, 是区分树的左右儿子节点的方式处理.
        // 如果能以对待根节点的方式对待所有节点, 很简洁, 见解法2
        while (!stack.isEmpty()) {
            // 所操作的 p 已入栈
            if (p.left != null) {
                p = p.left;
                ans.add(p.val);
                stack.push(p);
            } else {
                // 这样写真的很啰嗦, 因为我们使用 stack.peek 和 p 存储了当前需要处理节点的信息
                // 我们只要能获取当前节点的信息就好, 何必要双重, 很麻烦
                stack.pop(); // 当前节点入栈就处理了, 出栈, 然后处理它的右节点
                p = p.right;
                if (p != null) { // 由于区分树的左右儿子节点的方式处理, 这里还需要对右节点进行处理
                    ans.add(p.val);
                    stack.push(p);
                } else {
                    //由于是先序遍历, 最后处理右孩子, 根节点和左孩子处理过了,
                    // 我们不知道现在栈中是否还有元素, 所以要判断栈是否为空
                    if (!stack.isEmpty()) {
                        p = stack.peek();
                        p.left = null; // 关键一步
                    }
                }
            }
        }
        return ans;
    }
}

解法2

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        TreeNode p = root;
        List<Integer> ans = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();

        // p != null 有双重效果:
        // 第一, 第一次循环栈为空, 我们不需要先将 p 压栈
        // 第二, 由于是先序遍历, 最后处理右孩子, 根节点和左孩子处理过了,
        //       所以在处理右节点时, 栈可能是空的
        while (!stack.isEmpty() || p != null) {
            if (p != null) {
                ans.add(p.val);
                stack.push(p);
                p = p.left;
            } else {
                // 这里不用判断栈是否为空是由于, 循环条件二选一, p == null, 则栈就不为空
                p = stack.pop().right;
            }
        }
        return ans;

    }
}

递归解法

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new LinkedList<>();
        helper(root, ans);
        return ans;
    }
    public void helper(TreeNode root, List<Integer> ans) {
        // 函数返回值为 void， return 就好， 使用  return null 是错误的
        if (root == null) return;
        ans.add(root.val);
        helper(root.left, ans);
        helper(root.right, ans);
    }
}

中序遍历

中序遍历: 左-根-右, p.val 处理要在 p.left 和 p.right 处理之中

迭代解法

以下说根节点都是广义上的根节点

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        TreeNode p = root;
        List<Integer> ans = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();

        while (!stack.isEmpty() || p != null) {
            if (p != null) {  // 先处理根节点的右子树
                stack.push(p);
                p = p.left;
            } else { // 该分支含义为根节点的左子树已经搞定
                p = stack.pop();
                ans.add(p.val);  // 处理根节点
                p = p.right; // 处理根节点的右子树
            }
        }
        return ans;
    }
}

递归解法

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        TreeNode p = root;
        List<Integer> ans = new LinkedList<>();
        helper(p, ans);
        return ans;
    }

    private void helper(TreeNode root, List<Integer> ans) {
        if (root == null) return;
        helper(root.left, ans);
        ans.add(root.val);
        helper(root.right, ans);
    }
}

后序遍历

后序遍历: (左-右-根), p.val 处理要在 p.left 和 p.right 处理之后

在后序遍历中, 每个节点需要访问 2 次, 这意味着遍历完左子树之后要访问当前节点, 遍历完右子树后还需要访问当前节点, 但是 \(\color{red}{只有在第二次访问才会处理当前节点}\). 问题就是如何区分两次访问, 是遍历完左子树返回还是遍历完右子树返回?

解决方法: 当栈中出栈一个元素, 检查这个元素是否与栈顶元素右节点相同, 如果是, 则说明完成了左右子树遍历. 此时只需将栈顶元素出栈并输出该节点数据就好.

迭代解法

解法 1

左右根 ==> 根右左 ->stack-> 左右根

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        stack<int> element;
        TreeNode* p = root;
        stack<TreeNode*> st;
        vector<int> ans;

        // 使用循环代替递归，while 循环中要用到 栈是否为空的条件
        while (p || !st.empty()) {
            // 先处理根节点, 在处理右节点, 在处理左节点, 用的是栈的结构, 所以变成 左-右-根
            if (p) {
                st.push(p);
                 // 处理根节点
                element.push(p->val);
                 // 处理根节点右节点
                p = p->right;
            } else {
                p = st.top()->left;
                st.pop();
            }
        }
        while (!element.empty()) {
            ans.push_back(element.top());
            element.pop();
        }
        return ans;
    }
};

解法2

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {

        TreeNode p = root;
        List<Integer> ans = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();

        while (!stack.isEmpty() || p != null) {
            if (p != null) {
                stack.push(p);
                p = p.left; // 处理根节点左节点
            } else {
                // 当前栈顶元素左子树处理完成, 然后处理右子树
                // 当右子树为空的时候, 需要判断是不是 如下结构
                /*
                            / \
                           / \
                              \
                */             \
                if (stack.peek().right == null) {
                    // 如果左右节点皆为空, 处理根节点
                    p = stack.pop();
                    ans.add(p.val);

                    // 处理完根节点之后看看根节点的位置, 看它是在父节点的左节点还是右节点位置
                    // 如果是右节点的位置, 那么就一直回溯(由于左节点已经处理完, 右节点也处理完,
                    // 只需处理根), 直到栈为空或者节点为父节点的左子树.
                    while (!stack.isEmpty() && p == stack.peek().right) {
                        p = stack.pop();
                        ans.add(p.val);
                    }
                }
                if (!stack.isEmpty()) { // 后续遍历, 栈为空, 则遍历结束
                    p = stack.peek().right;
                } else {
                    break;
                }
            }
        }
        return ans;
    }
}

递归解法

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new LinkedList<>();
        helper(root, ans);
        return ans;
    }
    public void helper(TreeNode root, List<Integer> ans) {
        // 函数返回值为 void， return 就好， 使用  return null 是错误的
        if (root == null) return;
        helper(root.left, ans);
        helper(root.right, ans);
        ans.add(root.val);
    }
}

层次遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {

        TreeNode p = root;
        List<List<Integer>> ans = new LinkedList<>();
        List<Integer> res = new LinkedList<>();
        if (p == null) return ans;

        Queue<TreeNode> queue = new LinkedList();
        queue.add(root);
        while (!queue.isEmpty()) {
            TreeNode temp = queue.remove();
            res.add(temp.val);
            if (temp.left != null) queue.add(temp.left);
            if (temp.right != null) queue.add(temp.right);
        }
        ans.add(res);     

        return ans;
    }
}