Merge pull request #13 from neha629/tree-algos

trees

Author: cookie-byte

Data Structures/Tree/BOTTOM_VIEW_OF_BT.cpp

@@ -0,0 +1,27 @@
+void bottomView(Node *root)
+{
+   // Your Code Here
+    if(root==NULL)
+     return;
+    map<int,int> m;
+    int hd=0;
+    queue<pair<Node*,int>> q;
+    q.push({root,0});
+    while(!q.empty())
+    {
+        pair<Node*,int> temp=q.front();
+        q.pop();
+        hd=temp.second;
+        Node *node=temp.first;
+        m[hd]=node->data;
+        if(node->left!=NULL)
+          q.push({node->left,hd-1});
+        if(node->right!=NULL)
+          q.push({node->right,hd+1});
+    }
+    for(auto it=m.begin();it!=m.end();it++)
+    {
+            cout<<it->second<<" ";
+    }
+}
+

Data Structures/Tree/DiagonalSum.cpp

@@ -0,0 +1,19 @@
+void func(Node* node,int d,map<int,int> &m)
+{
+    if(node==NULL)
+     return;
+    m[d]+=node->data;
+     func(node->left,d+1,m);
+     func(node->right,d,m);
+}
+void diagonalSum(Node* root)
+{
+ // Add your code here
+ map<int,int> m;
+ func(root,0,m);
+ for(auto it=m.begin();it!=m.end();it++)
+ {
+    cout<<it->second<<" "; 
+ }
+ cout<<endl;
+}

Data Structures/Tree/Diameter_of_tree.cpp

@@ -0,0 +1,18 @@
+/* Computes the diameter of binary tree with given root.  */
+int dia(Node* node,int &ans)
+{
+    if(node==NULL)
+     return 0;
+    int lh=dia(node->left,ans);
+    int rh=dia(node->right,ans);
+    ans = max(ans,1+lh+rh);
+    return 1+max(lh,rh);
+}
+int diameter(Node* node)
+{
+   // Your code here
+   int ans = INT_MIN;
+   dia(node,ans);
+   return ans;
+}
+

Data Structures/Tree/Dijkstra_Algorithm.cpp

@@ -0,0 +1,32 @@
+// Output will be V space separated integers where the ith integer denote the shortest distance of ith vertex from given source vertex.
+int minkey(int V,bool mst[],int key[])
+{
+    int min=INT_MAX,minin;
+    for(int i=0;i<V;i++)
+    {
+        if(!mst[i] && key[i]<min)
+         min=key[i],minin=i;
+    }
+    return minin;
+}
+void dijkstra(vector<vector<int>> graph, int src, int V)
+{
+    // Your code here
+    bool mst[V];
+    int key[V];
+    for(int i=0;i<V;i++)
+     mst[i]=false,key[i]=INT_MAX;
+    key[src]=0;
+    for(int i=0;i<V-1;i++)
+    {
+        int u=minkey(V,mst,key);
+        mst[u]=true;
+        for(int v=0;v<V;v++)
+        {
+            if(graph[u][v] && !mst[v] && key[u]+graph[u][v]<key[v])
+             key[v]=key[u]+graph[u][v];
+        }
+    }
+    for(int i=0;i<V;i++)
+     cout<<key[i]<<" ";
+}

Data Structures/Tree/KOSARAJU'S_ALGORITHM.cpp

@@ -0,0 +1,50 @@
+// No of strongly connected components
+void fill(vector<int> adj[],int vis[],stack<int> &s,int i)
+{
+    vis[i]=1;
+    for(auto it:adj[i])
+    {
+        if(!vis[it])
+         fill(adj,vis,s,it);
+    }
+    s.push(i);
+}
+void dfs(vector<int> g[],int vis[],int i)
+{
+    vis[i]=1;
+    for(auto it:g[i])
+    {
+        if(!vis[it])
+         dfs(g,vis,it);
+    }
+}
+int kosaraju(int V, vector<int> adj[])
+{
+    // Your code here
+    int vis[V],c=0;
+    stack<int> s;
+    memset(vis,0,sizeof(vis));
+    for(int i=0;i<V;i++)
+    {
+        if(!vis[i])
+          fill(adj,vis,s,i);
+    }
+    vector<int> g[V+1];
+    for(int i=0;i<V;i++)
+    {
+        for(auto it:adj[i])
+          g[it].push_back(i);
+    }
+    memset(vis,0,sizeof(vis));
+    while(!s.empty())
+    {
+        int x=s.top();
+        s.pop();
+        if(!vis[x])
+        {
+          dfs(g,vis,x);
+          c++;
+        }
+    }
+    return c;
+}

Data Structures/Tree/LEFT_VIEW_OF_TREE.cpp

@@ -0,0 +1,18 @@
+void leftViewUtil(Node *root,int lvl,int &maxlvl)
+{
+    if(root==NULL)
+     return;
+    if(lvl>maxlvl)
+    {
+        cout<<root->data<<" ";
+        maxlvl=lvl;
+    }
+    leftViewUtil(root->left,lvl+1,maxlvl);
+    leftViewUtil(root->right,lvl+1,maxlvl);
+}
+void leftView(Node *root)
+{
+   // Your code here
+   int maxlvl=-1;
+   leftViewUtil(root,0,maxlvl);
+}

Data Structures/Tree/LOWEST_COMMON_ANCESTOR_OF_BST.cpp

@@ -0,0 +1,12 @@
+Node* LCA(Node *root, int n1, int n2)
+{
+   //Your code here
+   if(root==NULL)
+    return root;
+   if(root->data>n1 && root->data>n2)
+    return LCA(root->left,n1,n2);
+   if(root->data<n1 && root->data<n2)
+    return LCA(root->right,n1,n2);
+   return root;
+}
+

Data Structures/Tree/LOWEST_COMMON_ANCESTOR_OF_BT.cpp

@@ -0,0 +1,13 @@
+Node * lca(Node* root ,int n1 ,int n2 )
+{
+   //Your code here 
+   if(root==NULL)
+    return NULL;
+   if(root->data==n1 || root->data==n2)
+     return root;
+   Node *l=lca(root->left,n1,n2);
+   Node *r=lca(root->right,n1,n2);
+   if(l && r)
+    return root;
+   return (l!=NULL)?l:r;
+}

Data Structures/Tree/Prim's_Algorithm.cpp

@@ -0,0 +1,36 @@
+// Function to construct and print MST for
+// a graph represented using adjacency
+// matrix representation, with V vertices.
+// graph[i][j] = weight if edge exits else INT_MAX
+int minKey(int key[],bool mst[],int V)
+{
+    int min=INT_MAX,minin=0;
+    for(int i=0;i<V;i++)
+    {
+        if(mst[i]==false && key[i]<min)
+          min=key[i],minin=i;
+    }
+    return minin;
+}
+int spanningTree(int V,int E,vector<vector<int> > graph)
+{
+    // code here
+    int parent[V],key[V],s=0;
+    bool mst[V];
+    for(int i=0;i<V;i++)
+     key[i]=INT_MAX,mst[i]=false;
+    key[0]=0,parent[0]=-1;
+    for(int i=0;i<V-1;i++)
+    {
+       int u=minKey(key,mst,V);
+        mst[u]=true;
+        for(int v=0;v<V;v++)
+        {
+            if(graph[u][v] && mst[v]==false && graph[u][v]<key[v])
+             parent[v]=u,key[v]=graph[u][v];
+        }
+    }
+   for(int i=0;i<V;i++)
+     s+=key[i];
+     return s;
+}

Data Structures/Tree/TOP_VIEW_OF_BT.cpp

@@ -0,0 +1,28 @@
+void topView(struct Node *root)
+{
+    //Your code here
+    if(root==NULL)
+     return;
+    map<int,int> m;
+    int hd=0;
+    queue<pair<Node*,int>> q;
+    q.push({root,0});
+    while(!q.empty())
+    {
+        pair<Node*,int> temp=q.front();
+        q.pop();
+        hd=temp.second;
+        Node *node=temp.first;
+        if(m[hd]==0)
+        m[hd]=node->data;
+        if(node->left!=NULL)
+          q.push({node->left,hd-1});
+        if(node->right!=NULL)
+          q.push({node->right,hd+1});
+    }
+    for(auto it=m.begin();it!=m.end();it++)
+    {
+            cout<<it->second<<" ";
+    }
+}
+