├── LICENSE
├── README.md
├── checkifbalanced.cpp
├── diagonaltraversal.cpp
├── heightoftree.cpp
├── inorder.cpp
├── levelorderbfs.cpp
├── postorder.cpp
├── preorder.cpp
├── reverselevelorder.cpp
├── treeintro.cpp
├── verticalevlordertraversal.cpp
├── zigzag2.cpp
└── zigzagtraversal.cpp


/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Riti Kumari
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Binary Trees
 2 | 
 3 | 
 4 | - GitHub Repo : https://github.com/riti2409/trees-dsa
 5 | 
 6 | - Binary Trees :
 7 |   - https://www.youtube.com/playlist?list=PLgUwDviBIf0q8Hkd7bK2Bpryj2xVJk8Vk (Take U Forward)<br>
 8 |   - https://www.youtube.com/playlist?list=PLNxqWc8Uj2LRbsOlBiPJZAyZpaUwdDepd (Kashish Mehndiratta)<br>
 9 |            
10 | 
11 | - PDF(of notes): https://drive.google.com/file/d/13AcZJW7oUI8bw_04Ims1Os7x5ASYLztK/view?usp=sharing
12 | 
13 | Would love if you could add more resources :)
14 | 
15 | 


--------------------------------------------------------------------------------
/checkifbalanced.cpp:
--------------------------------------------------------------------------------
 1 | int solve(Node*root, int &f){
 2 |     if(!root) return 0;
 3 |     int l=solve(root->left,f);
 4 |     int r=solve(root->right,f);
 5 |     if(abs(l-r)>1)
 6 |     f=0;
 7 | return (1+max(l,r));
 8 | }
 9 | //Function to check whether a binary tree is balanced or not.
10 | bool isBalanced(Node *root)
11 | {
12 |     int f=1;
13 |     solve(root,f);
14 |     return f;
15 | }
16 | 


--------------------------------------------------------------------------------
/diagonaltraversal.cpp:
--------------------------------------------------------------------------------
 1 | vector<int> diagonal(Node *root)
 2 | {
 3 |     vector<int>ans;
 4 |    queue<Node*>q;
 5 |    if(!root) return ans;
 6 |    
 7 |    q.push(root);
 8 |    while(!q.empty()){
 9 |    Node*temp=q.front();
10 |    q.pop();
11 |    while(temp){
12 |        if(temp->left) q.push(temp->left);
13 |        ans.push_back(temp->data);
14 |        temp=temp->right;
15 |    }
16 |    
17 |    }
18 |    return ans;
19 |    
20 |    
21 | }


--------------------------------------------------------------------------------
/heightoftree.cpp:
--------------------------------------------------------------------------------
1 | class Solution{
2 |     public:
3 |     //Function to find the height of a binary tree.
4 |     int height(struct Node* node){
5 |         if(!node)
6 |         return 0;
7 |     return(1+max(height(node->left),height(node->right)));
8 |     }
9 | };


--------------------------------------------------------------------------------
/inorder.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode{
 4 |     int val;
 5 |     struct treenode *left;
 6 |     struct treenode *right;
 7 | 
 8 |     treenode(int data){
 9 |         val=data;
10 |         left=right=NULL;
11 | 
12 |     }
13 | };
14 | 
15 | void innorder(treenode*root){
16 |     if(!root) return;
17 |     vector<int>v;
18 |     
19 |     innorder(root->left);
20 |     cout<<root->val<<" ";
21 |     innorder(root->right);
22 |     
23 | }
24 | 
25 | 
26 | int main(){
27 | treenode * root=new treenode(12);
28 | root->left=new treenode(20);
29 | root->right=new treenode(10);
30 | root->left->left=new treenode(11);
31 | root->left->right=new treenode(17);
32 | root->right->left=new treenode(15);
33 | root->right->right=new treenode(18);
34 | 
35 | cout<<" inorder :";
36 | innorder(root);
37 | 
38 | return 0;
39 | }


--------------------------------------------------------------------------------
/levelorderbfs.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode
 4 | {
 5 |     int val;
 6 |     struct treenode *left;
 7 |     struct treenode *right;
 8 | 
 9 |     treenode(int data)
10 |     {
11 |         val = data;
12 |         left = right = NULL;
13 |     }
14 | };
15 | void levelorder(treenode *root)
16 | {
17 |     vector<int> vec;
18 |     if (!root)
19 |         return;
20 | 
21 |     queue<treenode *> q;
22 |     q.push(root);
23 |     while (!q.empty())
24 |     {
25 |         treenode *temp = q.front();
26 |         vec.push_back(temp->val);
27 |         if (temp->left)
28 |             q.push(temp->left);
29 |         if (temp->right)
30 |             q.push(temp->right);
31 |         q.pop();
32 |     }
33 |     for (auto x : vec)
34 |     {
35 |         cout << x << "->";
36 |     }
37 | }
38 |    
39 |     int main()
40 |     {
41 |         treenode *root = new treenode(12);
42 |         root->left = new treenode(20);
43 |         root->right = new treenode(10);
44 |         root->left->left = new treenode(11);
45 |         root->left->right = new treenode(17);
46 |         root->right->left = new treenode(15);
47 |         root->right->right = new treenode(18);
48 |         cout << "level order:";
49 |         levelorder(root);
50 |         
51 |         return 0;
52 |     }


--------------------------------------------------------------------------------
/postorder.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode{
 4 |     int val;
 5 |     struct treenode *left;
 6 |     struct treenode *right;
 7 | 
 8 |     treenode(int data){
 9 |         val=data;
10 |         left=right=NULL;
11 | 
12 |     }
13 | };
14 | 
15 | void postorder(treenode*root){
16 |     if(!root) return;
17 |     vector<int>v;
18 |    
19 |     postorder(root->left);
20 |     postorder(root->right);
21 |     cout<<root->val<<" ";
22 | }
23 | 
24 | int main(){
25 | treenode * root=new treenode(12);
26 | root->left=new treenode(20);
27 | root->right=new treenode(10);
28 | root->left->left=new treenode(11);
29 | root->left->right=new treenode(17);
30 | root->right->left=new treenode(15);
31 | root->right->right=new treenode(18);
32 | 
33 | cout<<"postorder :";
34 | postorder(root);
35 | return 0;
36 | }


--------------------------------------------------------------------------------
/preorder.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode{
 4 |     int val;
 5 |     struct treenode *left;
 6 |     struct treenode *right;
 7 | 
 8 |     treenode(int data){
 9 |         val=data;
10 |         left=right=NULL;
11 | 
12 |     }
13 | };
14 | void preorder(treenode*root){
15 |     if(!root) return;
16 |     vector<int>v;
17 |     cout<<root->val<<" ";
18 |     preorder(root->left);
19 |     preorder(root->right);
20 |     
21 | }
22 |  
23 | 
24 | int main(){
25 | treenode * root=new treenode(12);
26 | root->left=new treenode(20);
27 | root->right=new treenode(10);
28 | root->left->left=new treenode(11);
29 | root->left->right=new treenode(17);
30 | root->right->left=new treenode(15);
31 | root->right->right=new treenode(18);
32 | cout<<"preorder:";
33 | preorder(root);
34 | 
35 | return 0;
36 | }


--------------------------------------------------------------------------------
/reverselevelorder.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode
 4 | {
 5 |     int val;
 6 |     struct treenode *left;
 7 |     struct treenode *right;
 8 | 
 9 |     treenode(int data)
10 |     {
11 |         val = data;
12 |         left = right = NULL;
13 |     }
14 | };
15 | void reverselevelorder(treenode * root){  
16 |     vector<int> vec;
17 |         if (!root)
18 |             return;
19 | 
20 |         queue<treenode *> q;
21 |         q.push(root);
22 |         while (!q.empty())
23 |         {
24 |             treenode *temp = q.front();
25 |             vec.push_back(temp->val);
26 |             if (temp->left)
27 |                 q.push(temp->left);
28 |             if (temp->right)
29 |                 q.push(temp->right);
30 |             q.pop();
31 |         }
32 |         reverse(vec.begin(),vec.end());
33 |         for(auto &x : vec)
34 |         {
35 |             cout << x << "->";
36 |         }
37 | }
38 | 
39 |  int main()
40 |     {
41 |         treenode *root = new treenode(1);
42 |         root->left = new treenode(2);
43 |         root->right = new treenode(3);
44 |         root->left->left = new treenode(4);
45 |         root->left->right = new treenode(5);
46 |         root->right->left = new treenode(6);
47 |         root->right->right = new treenode(7);
48 |         cout << "reverselevel order:";
49 |         reverselevelorder(root);
50 |         
51 |         return 0;
52 |     }
53 | 


--------------------------------------------------------------------------------
/treeintro.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode{
 4 |     int val;
 5 |     struct treenode *left;
 6 |     struct treenode *right;
 7 | 
 8 |     treenode(int data){
 9 |         val=data;
10 |         left=right=NULL;
11 | 
12 |     }
13 | };
14 | void preorder(treenode*root){
15 |     if(!root) return;
16 |     vector<int>v;
17 |     cout<<root->val<<" ";
18 |     preorder(root->left);
19 |     preorder(root->right);
20 |     
21 | }
22 | void innorder(treenode*root){
23 |     if(!root) return;
24 |     vector<int>v;
25 |     
26 |     innorder(root->left);
27 |     cout<<root->val<<" ";
28 |     innorder(root->right);
29 |     
30 | }
31 | void postorder(treenode*root){
32 |     if(!root) return;
33 |     vector<int>v;
34 |    
35 |     postorder(root->left);
36 |     postorder(root->right);
37 |     cout<<root->val<<" ";
38 | }
39 | 
40 | int main(){
41 | treenode * root=new treenode(12);
42 | root->left=new treenode(20);
43 | root->right=new treenode(10);
44 | root->left->left=new treenode(11);
45 | root->left->right=new treenode(17);
46 | root->right->left=new treenode(15);
47 | root->right->right=new treenode(18);
48 | cout<<"preorder:";
49 | preorder(root);
50 | cout<<" inorder :";
51 | innorder(root);
52 | cout<<"postorder :";
53 | postorder(root);
54 | return 0;
55 | }


--------------------------------------------------------------------------------
/verticalevlordertraversal.cpp:
--------------------------------------------------------------------------------
 1 | void getverticalorder(Node*root,int hd,map<int,vector<int>>&m){
 2 |         if(!root) return;
 3 |         
 4 |         m[hd].push_back(root->data);
 5 |         if(root->left) getverticalorder(root->left,hd-1,m);
 6 |         if(root->right) getverticalorder(root->right,hd+1,m);
 7 |         
 8 |     }
 9 |     vector<int> verticalOrder(Node *root)
10 |     {
11 |         map<int,vector<int>> m;
12 |         int hd=0;
13 |         vector<int>vec;
14 |         getverticalorder(root,hd,m);
15 |         for(auto x:m){
16 |             for(auto y:x.second){
17 |                 vec.push_back(y);
18 |             }
19 |            
20 |         }
21 |          return vec;
22 | }


--------------------------------------------------------------------------------
/zigzag2.cpp:
--------------------------------------------------------------------------------
 1 | vector <int> zigZagTraversal(Node* root)
 2 | {
 3 |     vector<int>ans;
 4 | 	if(!root){
 5 | 	    return ans;
 6 | 	}
 7 | 	queue<Node*>q;
 8 | 	q.push(root);
 9 | 	int level=1;
10 | 	while(!q.empty()){
11 | 	    int sz=q.size();
12 | 	    
13 | 	    vector<int>t;
14 | 	    while(sz--){
15 | 	        Node*temp=q.front();
16 | 	        t.push_back(temp->data);
17 | 	        if(temp->left) q.push(temp->left);
18 | 	        if(temp->right) q.push(temp->right);
19 | 	        q.pop();
20 | 	    }
21 | 	    if(level%2==0)
22 | 	    reverse(t.begin(),t.end());
23 | 	    for(int i=0;i<t.size();i++)
24 | 	    ans.push_back(t[i]);
25 | 	    level=!level;
26 | 	}
27 | 	return ans;
28 | }


--------------------------------------------------------------------------------
/zigzagtraversal.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct treenode
 4 | {
 5 |     int data;
 6 |     struct treenode *left;
 7 |     struct treenode *right;
 8 | 
 9 |     treenode(int data)
10 |     {
11 |         this->data = data;
12 |         left = right = NULL;
13 |     }
14 | };
15 | void zigzagtraversal(treenode * root){  
16 |     vector<int> vec;
17 |     vector<vector<int>>sol;
18 |         if (!root)
19 |             return;
20 | 
21 |         stack<treenode*>st1;
22 |         stack<treenode*>st2;
23 | 
24 |         st1.push(root);
25 |         while(!st1.empty() || !st2.empty()){
26 |            while(!st1.empty()){
27 |             treenode*temp=st1.top();
28 |             vec.push_back(temp->data);
29 |             if(root->left) st2.push(root->left);
30 |             if(root->right) st2.push(root->right);
31 |             st1.pop();
32 |            }
33 |            if(vec.size()!=0){
34 |                sol.push_back(vec);
35 |                vec.clear();
36 | 
37 |            }
38 |            while(!st2.empty()){
39 |           treenode*temp=st2.top();
40 |             vec.push_back(temp->data);
41 |             if(root->left) st1.push(root->left);
42 |             if(root->right) st1.push(root->right);
43 |             st2.pop();
44 |            }
45 |            if(vec.size()!=0){
46 |                sol.push_back(vec);
47 |                vec.clear();
48 |                
49 |            }
50 |         }
51 | 
52 |         for (int i = 0; i < sol.size(); i++)
53 |     {
54 |         for (int j = 0; j < sol[i].size(); j++)
55 |         {
56 |             cout << sol[i][j] << " ";
57 |         }   
58 |        
59 |     }
60 | }
61 | 
62 |  int main()
63 |     {
64 |         treenode *root = new treenode(1);
65 |         root->left = new treenode(2);
66 |         root->right = new treenode(3);
67 |         root->left->left = new treenode(4);
68 |         root->left->right = new treenode(5);
69 |         root->right->left = new treenode(6);
70 |         root->right->right = new treenode(7);
71 |         cout << "zigzag:";
72 |         zigzagtraversal(root);
73 |         
74 |         return 0;
75 |     }
76 | 


--------------------------------------------------------------------------------