[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;    }};