[LeetCode] 103. Binary Tree Zigzag Level Order Traversal

题目链接: https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/description/

Description

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

解题思路

方法一：双栈
对于一棵二叉树，可以使用一个队列来实现从上到下从左到右遍历。同样，也可以使用栈来实现类似的遍历方法。初始化两个空栈，l2r_nodes 用来保存偶数层（根结点为第 0 层）从左到右遍历的结点，r2l_nodes 用来保存奇数层从右到左遍历的结点。

初始时，将根结点压入 l2r_nodes 中，当前层数 layer 赋值 0。不断检查当前层对应的栈是否为空，不为空则将栈顶弹出，结点值存到层数对应数组末尾，检查 left 和 right 指针是否为空，不为空则压入另一个栈中。注意，检查顺序与当前层数有关，由于栈的后进先出特性，奇偶层的顺序分别为，

• 偶数层：先左后右
• 奇数层：先右后左

判断当前层对应的栈是否为空，为空则将层数 + 1。

方法二：递归
对二叉树进行先序遍历，用一个变量来表示当前结点所属层数。对于每一个结点，检查层数变量，若为偶数，则在对应数组末尾添加结点值；若为奇数，则在对应数组首部插入结点值。然后，递归处理左右结点，传入的层数变量 + 1。

Code

方法一：双栈
可以将从左到右遍历，再从右到左遍历归为一组，一个 while 循环里遍历一组，也可以一个 while 循环里遍历一层，如下为只遍历一层的代码。

class Solution {
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode *root) {
        vector<vector<int>> res;
        stack<TreeNode *> l2r_nodes;
        stack<TreeNode *> r2l_nodes;
        if (root == NULL) return res;

        int layer = 0;
        l2r_nodes.push(root);
        TreeNode *cur_node;

        while ((layer % 2 == 0 && !l2r_nodes.empty()) ||
               (layer % 2 == 1 && !r2l_nodes.empty())) {
            if (layer == res.size())
                res.push_back(vector<int>());
            if (layer % 2 == 0) {
                cur_node = l2r_nodes.top();
                l2r_nodes.pop();

                res[layer].push_back(cur_node->val);

                if (cur_node->left != NULL)
                    r2l_nodes.push(cur_node->left);
                if (cur_node->right != NULL)
                    r2l_nodes.push(cur_node->right);

                if (l2r_nodes.empty()) {
                    layer++;
                }
            } else {
                cur_node = r2l_nodes.top();
                r2l_nodes.pop();

                res[layer].push_back(cur_node->val);

                if (cur_node->right != NULL)
                    l2r_nodes.push(cur_node->right);
                if (cur_node->left != NULL)
                    l2r_nodes.push(cur_node->left);

                if (r2l_nodes.empty()) {
                    layer++;
                }
            }
        }

        return res;
    }
};

方法二：递归

class Solution {
private:
    void traverse(std::vector<std::vector<int>>& res, int level, TreeNode* node) {
        if (!node) return;
        if (level >= res.size()) {
            res.emplace_back(std::vector<int>{node->val});
        } else if (level % 2 == 0) {
            res[level].emplace_back(node->val);
        } else {
            res[level].insert(res[level].begin(), node->val);
        }
        traverse(res, level + 1, node->left);
        traverse(res, level + 1, node->right);
    }
public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        std::vector<std::vector<int>> res;
        traverse(res, 0, root);
        return res;
    }
};