Skip to content

Commit 3792d6a

Browse files
Ayush GangulyAyush Ganguly
Ayush Ganguly
authored and
Ayush Ganguly
committed
Binary Trees
1 parent 578287c commit 3792d6a

9 files changed

+314
-0
lines changed

‎.vscode/settings.json

+9
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
{
2+
"files.associations": {
3+
"*.cpp": "cpp",
4+
"__locale": "cpp",
5+
"string": "cpp",
6+
"string_view": "cpp",
7+
"__string": "cpp"
8+
}
9+
}

‎Happy_number.cpp

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
public:
3+
bool isHappy(int n) {
4+
int new_n = n;
5+
int tries = 20;
6+
while (tries != 0){
7+
int sum = 0;
8+
while (new_n != 0) {
9+
int dig = new_n % 10;
10+
sum = sum + dig * dig;
11+
new_n = new_n / 10;
12+
}
13+
if (sum == 1) {
14+
return true;
15+
} else {
16+
new_n = sum;
17+
}
18+
tries--;
19+
}
20+
return false;
21+
}
22+
};

‎contains_Duplicate_II.cpp

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
using namespace std;
2+
class Solution {
3+
public:
4+
bool containsNearbyDuplicate(vector<int>& nums, int k) {
5+
unordered_map<int, int> utracker;
6+
for (int i = 0; i < nums.size(); i++) {
7+
if (utracker.find(nums[i]) != utracker.end()){
8+
auto it = utracker.find(nums[i]);
9+
if (abs(it->second - i) <= k){
10+
return true;
11+
} else {
12+
it->second = i;
13+
}
14+
} else {
15+
utracker[nums[i]] = i;
16+
}
17+
}
18+
return false;
19+
}
20+
};

‎invert_binary_tree.cpp

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

‎maximum_tree_depth.cpp

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
int maxDepth(TreeNode* root) {
15+
if (root == nullptr ) {
16+
return 0;
17+
}
18+
int maxDepth = 0;
19+
// tree level
20+
queue <TreeNode*> level;
21+
level.push(root);
22+
23+
while (!level.empty()) {
24+
int level_size = level.size();
25+
for (int i = 0; i < level_size; i++) {
26+
TreeNode* front = level.front();
27+
level.pop();
28+
if (front->right != nullptr) {
29+
level.push(front->right);
30+
}
31+
if (front->left != nullptr) {
32+
level.push(front->left);
33+
}
34+
}
35+
maxDepth++;
36+
}
37+
38+
return maxDepth;
39+
}
40+
};

‎reverse_words_string.cpp

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
using namespace std;
2+
class Solution {
3+
public:
4+
string reverseWords(string s) {
5+
vector<string> answer;
6+
string out = "";
7+
string word = "";
8+
9+
for (int i = 0; i < s.length(); ++i) {
10+
while ((s[i] != ' ') && (i < s.length())) {
11+
word = word + s[i];
12+
i++;
13+
}
14+
if (word != "") {
15+
answer.push_back(word);
16+
}
17+
word = "";
18+
}
19+
20+
for (int i = answer.size() - 1; i >= 0; --i) {
21+
out += answer[i];
22+
if (i != 0) {
23+
out += ' ';
24+
}
25+
}
26+
27+
return out;
28+
}
29+
30+
};

‎same_tree.cpp

+78
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,78 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
13+
using namespace std;
14+
class Solution {
15+
public:
16+
bool isSameTree(TreeNode* p, TreeNode* q) {
17+
if ((p == nullptr) && (q == nullptr)) {
18+
return true;
19+
}
20+
21+
if ((p == nullptr) || (q == nullptr)) {
22+
return false;
23+
}
24+
25+
if (p->val != q->val) {
26+
return false;
27+
}
28+
29+
return (isSameTree(p->right, q->right) && isSameTree(p->left, q->left));
30+
31+
32+
}
33+
};
34+
35+
// bool isSameTree(TreeNode* p, TreeNode* q) {
36+
// is_p = true;
37+
// Preorder(p);
38+
39+
// is_p = false;
40+
// Preorder(q);
41+
42+
// if (p_traverse.size() != q_traverse.size()) {
43+
// return false;
44+
// }
45+
46+
// for (int i = 0; i < p_traverse.size(); i++) {
47+
// if (p_traverse[i] != q_traverse[i]) {
48+
// return false;
49+
// }
50+
// }
51+
52+
// return true;
53+
// }
54+
55+
// void Preorder(TreeNode* node) {
56+
// if (node == nullptr) {
57+
// if (is_p) {
58+
// p_traverse.push_back(1000000);
59+
// } else {
60+
// q_traverse.push_back(1000000);
61+
// }
62+
63+
// }
64+
// if (node != nullptr) {
65+
// if (is_p) {
66+
// p_traverse.push_back(node->val);
67+
// } else {
68+
// q_traverse.push_back(node->val);
69+
// }
70+
// Preorder(node->left);
71+
// Preorder(node->right);
72+
// }
73+
// }
74+
75+
// private:
76+
// vector<int> p_traverse;
77+
// vector<int> q_traverse;
78+
// bool is_p;

‎symmetric_tree.cpp

+66
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,66 @@
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
using namespace std;
13+
class Solution {
14+
public:
15+
bool isSymmetric(TreeNode* root) {
16+
// iterative
17+
// queue<TreeNode*> q1;
18+
// queue<TreeNode*> q2;
19+
// q1.push(root->left);
20+
// q2.push(root->right);
21+
// TreeNode* left;
22+
// TreeNode* right;
23+
// while (!q1.empty() && !q2.empty()) {
24+
// left = q1.front();
25+
// q1.pop();
26+
// right = q2.front();
27+
// q2.pop();
28+
29+
// if ((left == nullptr) && (right == nullptr)) {
30+
// continue;
31+
// }
32+
// if ((left == nullptr) || (right == nullptr)) {
33+
// return false;
34+
// }
35+
// if (left->val != right->val) {
36+
// return false;
37+
// }
38+
39+
// q1.push(left->left);
40+
// q1.push(left->right);
41+
// q2.push(right->right);
42+
// q2.push(right->left);
43+
// }
44+
// return true;
45+
46+
// recursive
47+
if (root == nullptr) {
48+
return true;
49+
}
50+
51+
return findSymmetry(root->left, root->right);
52+
}
53+
54+
bool findSymmetry(TreeNode* left, TreeNode* right){
55+
if ((left == nullptr) && (right == nullptr)) {
56+
return true;
57+
}
58+
if ((left == nullptr) || (right == nullptr)) {
59+
return false;
60+
}
61+
if (left->val != right->val) {
62+
return false;
63+
}
64+
return (findSymmetry(left->left, right->right) && findSymmetry(left->right, right->left));
65+
}
66+
};

‎valid_Anagram.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
using namespace std;
2+
class Solution {
3+
public:
4+
bool isAnagram(string s, string t) {
5+
if (s.length() != t.length()) {
6+
return false;
7+
}
8+
unordered_map <char, int> count_anagram;
9+
for (auto i: s) {
10+
count_anagram[i]++;
11+
}
12+
13+
for (auto i: t) {
14+
count_anagram[i]--;
15+
}
16+
17+
for (auto i: count_anagram) {
18+
if (i.second != 0){
19+
return false;
20+
}
21+
}
22+
return true;
23+
}
24+
};

0 commit comments

Comments
 (0)