程序员面试金典 4.3

List of Depths：给定一棵二叉树，创建一个链表数组，每个链表包含树中每一层的节点。

看起来需要对二叉树进行层次遍历，但是这并不是必须的，只要知道当前在哪一层就可以了，所以可以采用先序遍历的方法，在遍历过程中额外传递一个level参数即可。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> listOfDepth(TreeNode* tree) {
        vector<ListNode*> vecList;
        createLevelList(tree, vecList, 0);
        return vecList;
    }
private:
    void createLevelList(TreeNode *root, vector<ListNode*> &vecList, const size_t level)
    {
        if(root == nullptr) return;
        if(level >= vecList.size()){
            vecList.push_back(new ListNode(root->val));
        }
        else{
            ListNode* curr = vecList[level];
            while(curr->next != nullptr){
                curr = curr->next;
            }
            curr->next = new ListNode(root->val);
        }
        createLevelList(root->left, vecList, level + 1);
        createLevelList(root->right, vecList, level + 1);
    }
};

当然也可以使用层次遍历的方法。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<ListNode*> listOfDepth(TreeNode* tree) {
        vector<ListNode*> vecList;
        deque<TreeNode*> dq;
        if(tree != nullptr){
            dq.push_back(tree);
        }
        while(!dq.empty()){
            ListNode* tail = nullptr;
            deque<TreeNode*> dqNext;
            while(!dq.empty()){
                TreeNode* front = dq.front();
                dq.pop_front();
                if(front == nullptr) continue;
                if(tail == nullptr){
                    tail = new ListNode(front->val);
                    vecList.push_back(tail);
                }
                else{
                    tail->next = new ListNode(front->val);
                    tail = tail->next;
                }
                dqNext.push_back(front->left);
                dqNext.push_back(front->right);
            }
            dq = dqNext;
        }
        return vecList;
    }
};

两个算法都是O(n)的时间复杂度。但在空间上，第一个算法在递归的过程中产生了O(logn)的空间用于level，第二个算法由于返回ListNode所以必须使用额外的O(logn)空间用于TreeNode队列。不过因为两个算法都返回了O(n)的数据，所以在大O的概念下两个算法的空间复杂度页是一样的。