[LeetCode]103. Binary Tree Zigzag Level Order Traversal--二叉树之字形遍历

103. Binary Tree Zigzag Level Order Traversal
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]
]

---

分析：简单分析就可以发现，每行都是先进后出，所以很显然需要用到栈。但需要注意一点，对于每一行，左右孩子入栈的顺序不同，需要专门标记一下，奇数行先左孩子后右孩子入栈，偶数行先右孩子后左孩子入栈。

/**
 * 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<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(root == NULL)
            return result;
        stack<TreeNode*>current, next;
        current.push(root);
        vector<int> oneLayer;
        bool flag = true;
        while(!current.empty()){
            TreeNode* pCur = current.top();
            current.pop();
            oneLayer.push_back(pCur->val);
            // 需要确定左右子树入栈的顺序
            // 用flag标记
            if(flag){
                if(pCur->left)
                    next.push(pCur->left);
                if(pCur->right)
                    next.push(pCur->right);
            }else{
                if(pCur->right)
                    next.push(pCur->right);
                if(pCur->left)
                    next.push(pCur->left);
            }

            if(current.empty()){
                result.push_back(oneLayer);
                oneLayer.clear();            // 清空
                swap(current, next);         // 直接交换
                flag = !flag;                // flag切换
            }
        }
        return result;
    }
};

也可以使用《剑指offer》中解法，思想是一样的，代码略微不同。

/**
 * 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<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> result;
        if(!root)
            return result;
        stack<TreeNode*> s[2];
        int current = 0;
        int next = 1;
        s[current].push(root);
        vector<int> v;
        while(!s[current].empty() || !s[next].empty()){
            TreeNode* pCur = s[current].top();
            s[current].pop();
            v.push_back(pCur->val);
            if(current == 0){
                if(pCur->left)
                    s[next].push(pCur->left);
                if(pCur->right)
                    s[next].push(pCur->right);
            }else{
                if(pCur->right)
                    s[next].push(pCur->right);
                if(pCur->left)
                    s[next].push(pCur->left);
            }
            if(s[current].empty()){
                current = 1 - current;
                next = 1 - next;
                result.push_back(v);
                v.clear();
            }
        }
        return result;
    }
};