层序遍历的各种用法

本文在层序遍历binary-tree-level-order-traversal的基础上稍加修改解决了以下题目。(不一定是以下每道题的最优解法，但是可以在会了层序遍历的基础上解题)
binary-tree-level-order-traversal-ii
binary-tree-zigzag-level-order-traversal
populating-next-right-pointers-in-each-node-ii

binary-tree-level-order-traversal-ii可以在层序遍历的基础上修改来解。

题目链接：牛客网
题目描述： 给定一个二叉树，返回该二叉树由底层到顶层的层序遍历，（从左向右，从叶子节点到根节点，一层一层的遍历）

解题思路：这个题和层序遍历binary-tree-level-order-traversal很像。

给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）

只需要把最后返回的vector<vector<int>>顺序翻转一下即可。

binary-tree-level-order-traversal代码：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode *root) {
        vector<vector<int>>res;
        if (root==NULL)
            return res;
        queue<TreeNode*>store;
        vector<int>cur;
        store.push(root);
        while(!store.empty()){
            cur.clear();
            int n = store.size();
            for (int i = 0; i < n;++i){
                TreeNode*node = store.front();
                store.pop();
                cur.push_back(node->val);
                if (node->left!=NULL)
                    store.push(node->left);
                if (node->right!=NULL)
                    store.push(node->right);
            }
            res.push_back(cur);
        }
        return res;
    }
};

binary-tree-level-order-traversal-ii代码：

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrderBottom(TreeNode *root) {
        vector<vector<int>>res;
        if (root==NULL)
            return res;
        queue<TreeNode*>store;
        vector<int>cur;
        store.push(root);
        while(!store.empty()){
            cur.clear();
            int n = store.size();
            for (int i = 0; i < n;++i){
                TreeNode*node = store.front();
                store.pop();
                cur.push_back(node->val);
                if (node->left!=NULL)
                    store.push(node->left);
                if (node->right!=NULL)
                    store.push(node->right);
            }
            res.push_back(cur);
        }
        int n=res.size();
        vector<vector<int>>res1;
        for(int i=n-1;i>=0;i--){
            res1.push_back(res[i]);
        }
        return res1;
    }
};

与其相似的题目binary-tree-zigzag-level-order-traversal也可以在层序遍历的基础上修改来解。

题目链接：牛客网
题目描述： 给定一个二叉树，返回该二叉树的之字形层序遍历，（从左向右，下一层从右向左，一直这样交替）

解题思路：只需要记录一个flag，将需要从右向左遍历层的vector<int>进行翻转即可。

/**
 * Definition for binary tree
 * 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>>res;
        if (root==NULL)
            return res;
        queue<TreeNode*>store;
        vector<int>cur;
        store.push(root);
        while(!store.empty()){
            cur.clear();
            int n = store.size();
            for (int i = 0; i < n;++i){
                TreeNode*node = store.front();
                store.pop();
                cur.push_back(node->val);
                if (node->left!=NULL)
                    store.push(node->left);
                if (node->right!=NULL)
                    store.push(node->right);
            }
            res.push_back(cur);
        }
        int n=res.size();
        vector<vector<int>>res1;
        int flag=0;
        for(int i=0;i<n;i++){
            if(flag==0){
                res1.push_back(res[i]);
                flag=1;
            }else if(flag==1){
                reverse(res[i].begin(), res[i].end());
                res1.push_back(res[i]);
                flag=0;
            }
        }
        return res1;
    }
};

与其相似的题目populating-next-right-pointers-in-each-node-ii也可以在层序遍历的基础上修改来解。

题目链接：牛客网
题目描述：
给定一个二叉树
struct TreeLinkNode {
TreeLinkNode *left;
TreeLinkNode *right;
TreeLinkNode *next;}
填充所有节点的next指针，指向它右兄弟节点。如果没有右兄弟节点，则应该将next指针设置为NULL。
初始时，所有的next指针都为NULL

解题思路：将层序遍历的vector<vector<int>>改为vector<vector<TreeLinkNode *>>，在每一层将节点存到vector里，然后遍历每一层vector，如果不是本层的最后一个节点，那么就让该节点的next指向下一个节点。因为层序遍历是每一层节点从左往右存的，所以节点的下一个节点一定是他的右兄弟。

/**
 * Definition for binary tree with next pointer.
 * struct TreeLinkNode {
 *  int val;
 *  TreeLinkNode *left, *right, *next;
 *  TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {}
 * };
 */
class Solution {
public:
    void connect(TreeLinkNode *root) {
        vector<vector<TreeLinkNode *>>res;
        if (root==NULL)
            return ;
        queue<TreeLinkNode*>store;
        vector<TreeLinkNode *>cur;
        store.push(root);
        while(!store.empty()){
            cur.clear();
            int n = store.size();
            for (int i = 0; i < n;++i){
                TreeLinkNode*node = store.front();
                store.pop();
                cur.push_back(node);
                if (node->left!=NULL)
                    store.push(node->left);
                if (node->right!=NULL)
                    store.push(node->right);
            }
            res.push_back(cur);
        }
        int n=res.size();
        for(int i=0;i<n;i++){
            int num=res[i].size();
            for(int j=0;j<num;j++){
                if(j+1!=num){
                    root=res[i][j];
                    root->next=res[i][j+1];
                }
            }
        }
        root=res[0][0];
    }
};