题一：leetcode 102 （二叉树的层次遍历）
(https://leetcode-cn.com/problems/binary-tree-level-order-traversal/submissions/)

给定一个二叉树，返回其按层次遍历的节点值。 （即逐层地，从左到右访问所有节点）。

解法1：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> data;
        queue<TreeNode*> nodeQueue;
        nodeQueue.push(root);
        helper(data, nodeQueue);
        return data;
    }
    void helper(vector<vector<int>>& data, queue<TreeNode*> que)
    {
        queue<TreeNode*> nextQue;
        vector<int> temp;
        if(que.empty()) return;
        while(!que.empty())
        {
            TreeNode* node = que.front();
            if(node)
            {
                temp.push_back(node->val);
                nextQue.push(node->left);
                nextQue.push(node->right);
            }
            que.pop();
        }
        if(!temp.empty()) { data.push_back(temp); }
        helper(data, nextQue);   
    }
};

题二：leetcode 515 （在每个树行中找最大值）
(https://leetcode-cn.com/problems/find-largest-value-in-each-tree-row/submissions/)

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        vector<int> data;
        queue<TreeNode*> nextQue;
        nextQue.push(root);
        helper(data, nextQue);
        return data;
    }
    void helper(vector<int>& data, queue<TreeNode*> que)
    {
        queue<TreeNode*> nextQue;
        if(que.empty()) return;

        //TreeNode* first = que.front();
        int maxVal = -1;
        bool flag = false;
        while(!que.empty())
        {
            TreeNode* node = que.front();
            if(node) 
            { 
                if(flag == false)
                {
                    maxVal = node->val;
                    flag = true;
                }
                maxVal = maxVal > node->val ? maxVal : node->val;
                nextQue.push(node->left);
                nextQue.push(node->right);
            }
            que.pop();
        }
        if(flag) data.push_back(maxVal);
        helper(data, nextQue);
    }
};

题三：面试题 04.03 （特定深度节点链表）
(https://leetcode-cn.com/problems/list-of-depth-lcci/submissions/)

class Solution {
public:
    vector<ListNode*> listOfDepth(TreeNode* tree) {
        vector<ListNode*> list;
        queue<TreeNode*> que;
        que.push(tree);
        helper(list, que);
        return list;
    }
    void helper(vector<ListNode*>& list, queue<TreeNode*> que)
    {
        queue<TreeNode*> nextQue;
        if(que.empty()) return;

        ListNode* head = nullptr;
        ListNode* pCur = nullptr;
        bool flag = false;
        while(!que.empty())
        {
            TreeNode* node = que.front();
            if(node)
            {
                nextQue.push(node->left);
                nextQue.push(node->right);
                ListNode *item = new ListNode(node->val);
                if(flag == false)
                {
                    head = item;
                    flag = true;
                    pCur = head;
                }
                else
                {
                    pCur->next = item;
                    pCur = pCur->next;
                }
            }
            que.pop();
        }
        if(head) list.push_back(head);
        helper(list, nextQue);
    }
};