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
的概念下两个算法的空间复杂度页是一样的。