LeetCode算法“Tree”专栏笔记
94. Binary Tree Inorder Traversal
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector inorderTraversal(TreeNode* root) {
vector output;
stack node_stack;
TreeNode* node = root;
while(node || !node_stack.empty())
{
while(node)
{
node_stack.push(node);
node = node->left;
}
node = node_stack.top();
output.push_back(node->val);
node_stack.pop();
node = node->right;
}
return output;
}
};
注：中等题，树的中序遍历，迭代需要处理好压入栈的顺序。
Runtime: 4 ms, faster than 86.64% of C++ online submissions for Binary Tree Inorder Traversal.
Memory Usage: 9.3 MB, less than 46.46% of C++ online submissions forBinary Tree Inorder Traversal.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSameTree(TreeNode* p, TreeNode* q) {
if(!p && !q)
return true;
if(!p || !q)
return false;
if(p->val != q->val)
return false;
return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
101. Symmetric Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
bool isSymmetric(TreeNode* root) {
if(!root)
return true;
return isSame(root->left, root->right);
}
bool isSame(TreeNode* root1, TreeNode* root2)
{
if(!root1 && !root2)
return true;
if(!root1 || !root2)
return false;
if(root1->val != root2->val)
return false;
return isSame(root1->left, root2->right) && isSame(root1->right, root2->left);
}
};
注：简单题，递归判断就好了，与上一题相似，本体是需要考察左子树的右子树和右子树的左子树等等是不是一样的。
Runtime: 4 ms, faster than 94.57% of C++ online submissions forSymmetric Tree.
Memory Usage: 14.9 MB, less than 53.10% of C++ online submissions forSymmetric Tree.
102. Binary Tree Level Order Traversal
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：中等题，二叉树层次遍历使用队列就好了。
Runtime: 8 ms, faster than 86.77% of C++ online submissions for Binary Tree Level Order Traversal.
Memory Usage: 13.8 MB, less than 78.30% of C++ online submissions forBinary Tree Level Order Traversal.
103. Binary Tree Zigzag Level Order Traversal
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> zigzagLevelOrder(TreeNode* root) {
stack node_stack1;
stack node_stack2;
vector> output;
vector cache;
bool sign = true;
if(!root)
return output;
node_stack1.push(root);
while(!node_stack1.empty() || !node_stack2.empty())
{
if(sign)
{
int size = node_stack1.size();
while(size--)
{
TreeNode* node = node_stack1.top();
cache.push_back(node->val);
if(node->left)
node_stack2.push(node->left);
if(node->right)
node_stack2.push(node->right);
node_stack1.pop();
}
}
else
{
int size = node_stack2.size();
while(size--)
{
TreeNode* node = node_stack2.top();
cache.push_back(node->val);
if(node->right)
node_stack1.push(node->right);
if(node->left)
node_stack1.push(node->left);
node_stack2.pop();
}
}
output.push_back(cache);
cache.clear();
sign = !sign;
}
return output;
}
};
注：中等题，与上一题相似。使用两个栈并改变压入栈顺序即可。
Runtime: 4 ms, faster than 95.99% of C++ online submissions for Binary Tree Zigzag Level Order Traversal.
Memory Usage: 13.8 MB, less than 20.37% of C++ online submissions forBinary Tree Zigzag Level Order Traversal.
104. Maximum Depth of Binary Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
int maxDepth(TreeNode* root) {
if(!root)
return 0;
return max(maxDepth(root->left), maxDepth(root->right))+1;
}
};注：简单题，递归判断就好了。
Runtime: 12 ms, faster than 86.43% of C++ online submissions forMaximum Depth of Binary Tree.
Memory Usage: 19.5 MB, less than 38.82% of C++ online submissions forMaximum Depth of Binary Tree.
105.Construct Binary Tree from Preorder and Inorder Traversal
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* buildTree(vector& preorder, vector& inorder) {
if(preorder.size()==0 or inorder.size()==0 or inorder.size()!=preorder.size())
return NULL;
int preleft = 0;
return build(preorder, inorder, preleft, preorder.size(), 0, inorder.size());
}
TreeNode* build(vector& preorder, vector& inorder, int &preleft, int preright, int inleft, int inright)
{
if(inleft>=inright)
return NULL;
TreeNode* root = new TreeNode(preorder[preleft]);
int mid = binarysearch(inorder, inleft, inright, preorder[preleft]);
preleft+=1;
root->left = build(preorder, inorder, preleft, preright, inleft, mid);
root->right = build(preorder, inorder, preleft, preright, mid+1, inright);
return root;
}
int binarysearch(vector& inorder, int inleft, int inright, int target)
{
for(int i=inleft;i
注：中等题，掌握中序遍历与前序遍历的规律，递归就好了。
Runtime: 20 ms, faster than 76.54% of C++ online submissions forConstruct Binary Tree from Preorder and Inorder Traversal.
Memory Usage: 16.4 MB, less than 87.71% of C++ online submissions forConstruct Binary Tree from Preorder and Inorder Traversal.
106. Construct Binary Tree from Inorder and Postorder Traversal
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* buildTree(vector& inorder, vector& postorder) {
if(postorder.size()==0 or inorder.size()==0 or inorder.size()!=postorder.size())
return NULL;
int preright = postorder.size()-1;
return build(postorder, inorder, 0, preright, 0, inorder.size());
}
TreeNode* build(vector& postorder, vector& inorder, int preleft, int &preright, int inleft, int inright)
{
if(inleft>=inright)
return NULL;
TreeNode* root = new TreeNode(postorder[preright]);
int mid = binarysearch(inorder, inleft, inright, postorder[preright]);
preright-=1;
root->right = build(postorder, inorder, preleft, preright, mid+1, inright);
root->left = build(postorder, inorder, preleft, preright, inleft, mid);
return root;
}
int binarysearch(vector& inorder, int inleft, int inright, int target)
{
for(int i=inleft;i
注：中等题，105的代码改一下，左右子树递归的顺序换一下就行了。
Runtime: 20 ms, faster than 73.43% of C++ online submissions forConstruct Binary Tree from Inorder and Postorder Traversal.
Memory Usage: 16.6 MB, less than 80.99% of C++ online submissions forConstruct Binary Tree from Inorder and Postorder Traversal.
107. Binary Tree Level Order Traversal II
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrderBottom(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
reverse(output.begin(), output.end());
return output;
}
};
注：简单题，把103的结果reverse一下就好了。
Runtime: 8 ms, faster than 88.23% of C++ online submissions for Binary Tree Level Order Traversal II.
Memory Usage: 14 MB, less than 51.23% of C++ online submissions forBinary Tree Level Order Traversal II.
108. 将有序数组转换为二叉搜索树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* sortedArrayToBST(vector& nums) {
if(nums.size()==0)
return nullptr;
return BuildBST(nums, 0, nums.size()-1);
}
TreeNode* BuildBST(vector& nums, int left, int right)
{
if(left>right)
return nullptr;
int mid = left + (right - left)/2;
TreeNode* root = new TreeNode(nums[mid]);
root->left = BuildBST(nums, left, mid-1);
root->right = BuildBST(nums, mid+1, right);
return root;
}
};
注：简单题，二叉递归建立就好了。
执行用时 :20 ms, 在所有 C++ 提交中击败了97.02%的用户。
内存消耗 :20.8 MB, 在所有 C++ 提交中击败了97.19%的用户。
109. 有序链表转换二叉搜索树
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.
100. Same Tree
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector> levelOrder(TreeNode* root) {
queue node_queue;
vector> output;
vector cache;
if(!root)
return output;
node_queue.push(root);
while(!node_queue.empty())
{
int size = node_queue.size();
while(size--)
{
TreeNode* node = node_queue.front();
cache.push_back(node->val);
if(node->left)
node_queue.push(node->left);
if(node->right)
node_queue.push(node->right);
node_queue.pop();
}
output.push_back(cache);
cache.clear();
}
return output;
}
};
注：简单题，递归判断就好了。
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Same Tree.
Memory Usage: 9.9 MB, less than 48.44% of C++ online submissions forSame Tree.