leetcode_c++：栈：Binary Tree Zigzag Level Order Traversal(103)

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]
]

//求层次遍历，但是奇数层要是反着的输出

---

http://www.acmerblog.com/leetcode-solution-binary-tree-zigzag-level-order-traversal-6239.html

//广度优先遍历，用一个bool记录是从左到右还是从右到左，每一层结束就翻转一下。

// 迭代版，时间复杂度O(n)，空间复杂度O(n)

---

#include <iostream>
#include <vector>
#include<cmath>
#include <algorithm>
#include <stack>
#include <string>
#include <sstream>
#include <queue>

using namespace std;


struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x): val(x),left(NULL),right(NULL){}
};


//LeetCode, Binary Tree Zigzag Level Order Traversal
//广度优先遍历，用一个bool记录是从左到右还是从右到左，每一层结束就翻转一下。
// 迭代版，时间复杂度O(n)，空间复杂度O(n)
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        vector<vector<int> > result;
        if (nullptr == root) return result;

        queue<TreeNode*> q;
        bool left_to_right = true;  //left to right
        vector<int> level;  // one level's elements

        q.push(root);
        q.push(nullptr);  // level separator
        while (!q.empty()) {
            TreeNode *cur = q.front();
            q.pop();
            if (cur) {
                level.push_back(cur->val);
                if (cur->left) q.push(cur->left);
                if (cur->right) q.push(cur->right);
            } else {
                if (left_to_right) {
                    result.push_back(level);
                } else {
                    reverse(level.begin(), level.end());
                    result.push_back(level);
                }
                level.clear();
                left_to_right = !left_to_right;

                if (q.size() > 0) q.push(nullptr);
            }
        }

        return result;
    }
};

TreeNode* CreateTree(int a[],int n){
    if(n<=0)  return NULL;

    TreeNode** tree=new TreeNode*[n];

    for(int i=0;i<n;i++){
        if(a[i]==0){
            tree[i]=NULL;
            continue;
        }
        tree[i]=new TreeNode(a[i]);
    }
    int pos=1;
    for(int i=0;i<n && pos<n;i++){
        if(tree[i]){
            tree[i]->left=tree[pos++];
            if(pos<n){
                tree[i]->right=tree[pos++];
            }
        }
    }

    return tree[0];
}

void printTree_level_order(TreeNode* root){
    queue<TreeNode*> q;
    q.push(root);
    while(q.size()>0){
        TreeNode* n=q.front();
        q.pop();
        if(n==NULL){
            cout<<"# ";
            continue;
        }
        cout<<n->val<<" ";
        q.push(n->left);
        q.push(n->right);
    }
    cout<<endl;
}


int printMatrix(vector<vector<int> > &vv){
    for(int i=0;i<vv.size();i++){
        cout<<"[";
        for(int j=0;j<vv[i].size();j++)
            cout<<" "<<vv[i][j];
        cout<<"]"<<endl;
    }


}


int main(int argc,char** argv){

    Solution st;
    TreeNode* p;
    vector<vector<int> > vv;
    int a[]={3,9,20,0,0,15,7};
    p=CreateTree(a,sizeof(a)/sizeof(int));
    printTree_level_order(p);
    vv=st.zigzagLevelOrder(p);
    printMatrix(vv);
    cout<<endl;
}

---

递归版本

// LeetCode, Binary Tree Zigzag Level Order Traversal
// 递归版，时间复杂度O(n)，空间复杂度O(n)
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        vector<vector<int>> result;
        traverse(root, 1, result, true);
        return result;
    }

    void traverse(TreeNode *root, size_t level, vector<vector<int>> &result,
            bool left_to_right) {
        if (!root) return;

        if (level > result.size())
            result.push_back(vector<int>());

        if (left_to_right)
            result[level-1].push_back(root->val);
        else
            result[level-1].insert(result[level-1].begin(), root->val);

        traverse(root->left, level+1, result, !left_to_right);
        traverse(root->right, level+1, result, !left_to_right);
    }
};