Skip to content

Commit fcea9ce

Browse files
PhoenixDDPhoenixDD
committed
Initial commit
1 parent 9ea8ae8 commit fcea9ce

21 files changed

+618
-0
lines changed

‎101-Symmetric Tree.cpp

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
bool isSymmetric(TreeNode* root)
13+
{
14+
if(!root)
15+
return true;
16+
return isMirror(root->left,root->right);
17+
}
18+
bool isMirror(TreeNode* left, TreeNode* right)
19+
{
20+
if(!left&&!right)
21+
return true;
22+
else if(!left||!right)
23+
return false;
24+
return left->val==right->val&&isMirror(left->left,right->right)&&isMirror(left->right,right->left);
25+
}
26+
};

‎102-Binary Tree Level Order Traversal.cpp

+33
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
vector<vector<int>> result;
13+
int max_d=0;
14+
void levelOrder(TreeNode* root,int depth)
15+
{
16+
if(root)
17+
{
18+
max_d=depth>max_d?depth:max_d;
19+
result[depth].push_back(root->val);
20+
levelOrder(root->left,depth+1);
21+
levelOrder(root->right,depth+1);
22+
}
23+
}
24+
vector<vector<int>> levelOrder(TreeNode* root)
25+
{
26+
if(!root)
27+
return {};
28+
result.resize(1000);
29+
levelOrder(root,0);
30+
result.resize(max_d+1);
31+
return result;
32+
}
33+
};

‎103-Binary Tree Zigzag Level Order Traversal.cpp

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
vector<vector<int>> result;
13+
int max_d=0;
14+
void zigzagLevelOrder(TreeNode* root,int depth)
15+
{
16+
if(root)
17+
{
18+
max_d=depth>max_d?depth:max_d;
19+
if(depth&1)
20+
result[depth].insert(result[depth].begin(),root->val);
21+
else
22+
result[depth].push_back(root->val);
23+
zigzagLevelOrder(root->left,depth+1);
24+
zigzagLevelOrder(root->right,depth+1);
25+
}
26+
}
27+
vector<vector<int>> zigzagLevelOrder(TreeNode* root)
28+
{
29+
if(!root)
30+
return {};
31+
result.resize(1000);
32+
zigzagLevelOrder(root,0);
33+
result.resize(max_d+1);
34+
return result;
35+
}
36+
};

‎104-Maximum Depth of Binary Tree.cpp

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
int maxDepth(TreeNode* root)
13+
{
14+
if(!root)
15+
return 0;
16+
return 1+max(maxDepth(root->right),maxDepth(root->left));
17+
}
18+
};

‎105-Construct Binary Tree from Preorder and Inorder Traversal.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
int pre_ind=0;
13+
unordered_map<int,int> indexes;
14+
TreeNode* build(vector<int>& pre, vector<int>& in,int start,int end)
15+
{
16+
if(start>end)
17+
return NULL;
18+
TreeNode* node=new TreeNode(pre[pre_ind++]);
19+
if(start==end)
20+
return node;
21+
node->left=build(pre,in,start,indexes[node->val]-1);
22+
node->right=build(pre,in,indexes[node->val]+1,end);
23+
return node;
24+
}
25+
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
26+
{
27+
indexes.reserve(inorder.size());
28+
for(int i=0;i<inorder.size();i++)
29+
indexes[inorder[i]]=i;
30+
return build(preorder,inorder,0,inorder.size()-1);
31+
}
32+
};

‎106-Construct Binary Tree from Inorder and Postorder Traversal.cpp

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
int pre_ind=0;
13+
unordered_map<int,int> indexes;
14+
TreeNode* build(vector<int>& pre, vector<int>& in,int start,int end)
15+
{
16+
if(start>end)
17+
return NULL;
18+
TreeNode* node=new TreeNode(pre[pre_ind++]);
19+
if(start==end)
20+
return node;
21+
node->left=build(pre,in,start,indexes[node->val]-1);
22+
node->right=build(pre,in,indexes[node->val]+1,end);
23+
return node;
24+
}
25+
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder)
26+
{
27+
indexes.reserve(inorder.size());
28+
for(int i=0;i<inorder.size();i++)
29+
indexes[inorder[i]]=i;
30+
return build(preorder,inorder,0,inorder.size()-1);
31+
}
32+
};

‎107-Binary Tree Level Order Traversal II.cpp

+38
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
vector<vector<int>> result;
13+
int max_depth;
14+
int get_depth(TreeNode* root)
15+
{
16+
if(!root)
17+
return 0;
18+
return 1+max(get_depth(root->left),get_depth(root->right));
19+
}
20+
void levelOrderBottom(TreeNode* root,int depth)
21+
{
22+
if(root)
23+
{
24+
result[max_depth-depth].push_back(root->val);
25+
levelOrderBottom(root->left,depth+1);
26+
levelOrderBottom(root->right,depth+1);
27+
}
28+
}
29+
vector<vector<int>> levelOrderBottom(TreeNode* root)
30+
{
31+
if(!root)
32+
return {};
33+
max_depth=get_depth(root);
34+
result.resize(max_depth);
35+
levelOrderBottom(root,1);
36+
return result;
37+
}
38+
};

‎108-Convert Sorted Array to Binary Search Tree.cpp

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
TreeNode* sortedArrayToBST(vector<int>& nums,int start,int end)
13+
{
14+
if(start>end)
15+
return NULL;
16+
int mid=(start+end)/2;
17+
TreeNode* Node=new TreeNode(nums[mid]);
18+
if(start==end)
19+
return Node;
20+
Node->left=sortedArrayToBST(nums,start,mid-1);
21+
Node->right=sortedArrayToBST(nums,mid+1,end);
22+
return Node;
23+
}
24+
TreeNode* sortedArrayToBST(vector<int>& nums)
25+
{
26+
return sortedArrayToBST(nums,0,nums.size()-1);
27+
}
28+
};

‎109-Convert Sorted List to Binary Search Tree.cpp

+44
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* struct ListNode {
4+
* int val;
5+
* ListNode *next;
6+
* ListNode(int x) : val(x), next(NULL) {}
7+
* };
8+
*/
9+
/**
10+
* Definition for a binary tree node.
11+
* struct TreeNode {
12+
* int val;
13+
* TreeNode *left;
14+
* TreeNode *right;
15+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
16+
* };
17+
*/
18+
class Solution {
19+
public:
20+
vector<ListNode*> all_indices;
21+
TreeNode* sortedListToBST(int start,int end)
22+
{
23+
if(start>end)
24+
return NULL;
25+
int mid=(start+end)/2;
26+
TreeNode* Node=new TreeNode(all_indices[mid]->val);
27+
if(start==end)
28+
return Node;
29+
Node->left=sortedListToBST(start,mid-1);
30+
Node->right=sortedListToBST(mid+1,end);
31+
return Node;
32+
}
33+
TreeNode* sortedListToBST(ListNode* head)
34+
{
35+
all_indices.reserve(1000);
36+
ListNode* temp=head;
37+
while(temp)
38+
{
39+
all_indices.push_back(temp);
40+
temp=temp->next;
41+
}
42+
return sortedListToBST(0,all_indices.size()-1);
43+
}
44+
};

‎110-Balanced Binary Tree.cpp

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
int height(TreeNode* root)
13+
{
14+
if(!root)
15+
return 0;
16+
int left=height(root->left);
17+
if(left==-1)
18+
return -1;
19+
int right=height(root->right);
20+
if(right==-1||abs(left-right)>1)
21+
return -1;
22+
return 1+max(left,right);
23+
24+
}
25+
bool isBalanced(TreeNode* root)
26+
{
27+
return height(root)!=-1;
28+
}
29+
};

‎111-Minimum Depth of Binary Tree.cpp

+43
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
8+
* };
9+
*/
10+
class Solution {
11+
public:
12+
int height(TreeNode* root)
13+
{
14+
if(!root)
15+
return 0;
16+
int left=height(root->left);
17+
if(left==-1)
18+
return -1;
19+
int right=height(r/**
20+
* Definition for a binary tree node.
21+
* struct TreeNode {
22+
* int val;
23+
* TreeNode *left;
24+
* TreeNode *right;
25+
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
26+
* };
27+
*/
28+
class Solution {
29+
public:
30+
int minDepth(TreeNode* root)
31+
{
32+
if(!root)
33+
return 0;
34+
if(root->right&&root->left)
35+
return 1+min(minDepth(root->left),minDepth(root->right));
36+
else if(root->right)
37+
return 1+minDepth(root->right);
38+
else if(root->left)
39+
return 1+minDepth(root->left);
40+
else
41+
return 1;
42+
}
43+
};

0 commit comments

Comments
 (0)