【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。

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

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