【LeetCode】103. Binary Tree Zigzag Level Order Traversal

【LeetCode】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,#,#,15,7},
    3
   / \
  9  20
    /  \
   15   7
[
  [3],
  [20,9],
  [15,7]
]
struct Node
{
    TreeNode* tNode;
    int level;
    Node(TreeNode* newtNode, int newlevel): tNode(newtNode), level(newlevel) {}
};
class Solution {
public:
    vector<vector<int> > zigzagLevelOrder(TreeNode *root) {
        vector<vector<int> > ret;
        if(!root)
            return ret;
        // push root 
        Node* rootNode = new Node(root, 0);
        queue<Node*> Nqueue;
        Nqueue.push(rootNode);
        vector<int> cur;
        int curlevel = 0;
        while(!Nqueue.empty())
        {
            Node* frontNode = Nqueue.front();
            Nqueue.pop();
            if(frontNode->level > curlevel)
            {
                if(curlevel%2 == 1)
                    reverse(cur.begin(), cur.end());
                ret.push_back(cur);
                cur.clear();
                curlevel = frontNode->level;
            }
            cur.push_back(frontNode->tNode->val);
            if(frontNode->tNode->left)
            {
                Node* leftNode = new Node(frontNode->tNode->left, frontNode->level+1);
                Nqueue.push(leftNode);
            }
            if(frontNode->tNode->right)
            {
                Node* rightNode = new Node(frontNode->tNode->right, frontNode->level+1);
                Nqueue.push(rightNode);
            }
        }
        if(curlevel%2 == 1)
            reverse(cur.begin(), cur.end());
        ret.push_back(cur);
        return ret;
    }
};

这道题，立刻要反应出来是和牛客网上的二叉树按行打印有异曲同工之妙

抛去奇数行翻转噱头不谈。首先有个临时队列Nqueue，不光存点还存点的层数。还有个临时vector是cur。这个只存Nqueue中的头。当这个点成为Nqueue的头了，那么该点的左右子树就要存Nqueue的后面排队。所谓风水轮流转，老大轮流当。一旦，我检测到层中的层不是当前层了，我便改朝换代。cur的推入结果，什么层数更新等等。

牛客网上的题目是

有一棵二叉树，请设计一个算法，按照层次打印这棵二叉树。

给定二叉树的根结点root，请返回打印结果，结果按照每一层一个数组进行储存，所有数组的顺序按照层数从上往下，且每一层的数组内元素按照从左往右排列。保证结点数小于等于500。

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class TreePrinter {
public:
    vector<vector<int> > printTree(TreeNode* root) {
        TreeNode * pre=root;
        vector<vector<int>> total;
        int h=1;
        vector<TreeNode*> stack;       
        stack.push_back(pre);
        TreeNode* out;
        int n=0;      
        while(h)//h为这层子节点数，n为下一层子节点数
        {    
            vector<int> child;
            n=0;
            for(int i=0;i<h;i++)
            {
                out=stack[0];
                child.push_back(out->val);
                if(out->left!=NULL) {stack.push_back(out->left); n++;}
                if(out->right!=NULL) {stack.push_back(out->right); n++;}
                stack.erase(stack.begin());               
            }
            total.push_back(child);           
            h=n;
        }
        return total;
        // write codtoe here
    }
};

同样，一个临时的vector，就是stack。同样，里面的老大出来，进入child，接着把你的小弟丢入stack后面排队去。同时呢，你有多少个小弟我都统统做好记录。就是n。一个for循环，循环出我们这一代的所有兄弟，所有这些兄弟的小弟都要做记录。都丢入了stack。当for循环结束，兄弟不在，改朝换代，n变成了h。child进入total。新的江湖就开始了。直到这个世界没有了小弟的大哥，也死了。

注意几个点。

1.都要找一个临时队列。队列结束，整个二叉树就结束，每次都取临时队列的头进行处理（老大）

2.每次这个头（老大）的先左子树后右子树（小弟）插入临时队列中，要记录层（代）。

3.这层子树结束了开始下一层。所有的老大成为历史被记录，所有的小弟摇身变成了老大。

图的深度遍历

对不起，这个脑洞开得有点大。代码详见大话数据结构P243。

同样，是老大和小弟的关系。只不过这里老大有很多个小弟。老大才有资格被打印，小弟则是被丢入临时队列中。老大是经过临时队列和时间的历练而成的。

所以，看这两题的时候也重看下深度遍历把。