LeetCode 103 Binary Tree Zigzag Level Order Traversal 题解

题意简述：给出一棵二叉树，要求按以下顺序遍历：第一层结点由左到右，第二层结点由右到左，第三层结点由左到右如此重复。
输入：二叉树的根结点root
输出：嵌套vector，一个vector包含同一层结点的遍历顺序
示例：对于左下的二叉树，它的遍历结果如右下所示
　　3　　　　　　　　　　　　　　　　[
　/　 \　　　　　　　　　　　　　　　　[3],
9 　　20　　　　　　　　　　　　　　　[20,9],
　　/　 \　　　　　　　　　　　　　　　[15,7]
　　15 　7　　　　　　　　　　　　 　]

---

题解：
既然是二叉树，就可以采用递归的思路。递归的时候可以先不考虑左右方向的问题，默认每一层都是由左向右遍历，得到整棵树的结果时再根据需要将第二、四、……层反转。
遍历根结点为root的二叉树，步骤如下：

1. 首先将只包含根结点值的vector加入到存放结果的嵌套vector（变量名为res）中；
2. 递归得到root的左右子树的遍历结果，递归完成将返回两个嵌套vector（称为resl和resr）；
3. 将resl和resr逐层合并，resl的元素在左，resr的元素在右。合并的方法是新建一个vector，先加入resl某一层的元素，再加入resr同一层的元素（resl和resr同一下标的vector对应同一层）；
4. 将合并后的vector逐层加入res，然后返回res。

合并操作需要考虑的细节较多，包括resl和resr有空集时的处理，resl和resr层数不相等时的处理。

/**
 * 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 {
private:
    vector<vector<int>> dfs(TreeNode* root) {
        vector<vector<int>> res;
        if(root == NULL) return res;

        vector<vector<int>> resl, resr;
        resl = dfs(root->left);
        resr = dfs(root->right);

        // root
        vector<int> vecroot;
        vecroot.push_back(root->val);
        res.push_back(vecroot);

        // left & right combine
        if(!(resl.size() == 0 && resr.size() == 0)) {
            if(resl.size() == 0) {
                res.insert(res.end(), resr.begin(), resr.end());
            } else if(resr.size() == 0) {
                res.insert(res.end(), resl.begin(), resl.end());
            } else {
                int uni = min(resl.size(), resr.size());
                for(int i = 0;i < uni;i++) {
                    vector<int> temp;
                    temp.insert(temp.end(), resl[i].begin(), resl[i].end());
                    temp.insert(temp.end(), resr[i].begin(), resr[i].end());
                    res.push_back(temp);
                }
                if(resl.size() >= resr.size()) {
                    res.insert(res.end(), resl.begin()+uni, resl.end());
                } else {
                    res.insert(res.end(), resr.begin()+uni, resr.end());
                }
            }        
        }

        return res;
    }

    void myreverse(vector<vector<int>>& res) {
        for(int i = 1;i < res.size();i+=2) {
            reverse(res[i].begin(), res[i].end());
        }
    }

public:
    vector<vector<int>> zigzagLevelOrder(TreeNode* root) {
        vector<vector<int>> res = dfs(root);
        myreverse(res);

        return res;
    }
};