diff --git a/drivercode/BSTDriver b/drivercode/BSTDriver
new file mode 100755
index 0000000..667ea48
Binary files /dev/null and b/drivercode/BSTDriver differ
diff --git a/drivercode/BSTDriver.cpp b/drivercode/BSTDriver.cpp
index 5bc7709..c2cb560 100644
--- a/drivercode/BSTDriver.cpp
+++ b/drivercode/BSTDriver.cpp
@@ -3,7 +3,8 @@
 #include<iostream>
 #include<vector>
 #include<stdlib.h>
-
+#include <algorithm> 
+#include <queue>
 
 using namespace std; 
 
@@ -11,68 +12,203 @@ class TreeNode {
   public: 
   int val; 
   TreeNode * left; 
-  TreeNode * right; 
-  // Add constructor. 
+  TreeNode * right;
+ 
+  // Add constructor.
+  TreeNode(){
+    
+    this->right = this->left  = NULL;
+  } 
+  TreeNode(int val){
+    this->val = val;
+    this->right = this->left  = NULL;
+  }
 }; 
 
 vector<int> generateRandomArray(int size) {
-  return vector<int>(size); 
+  vector<int> arr(size);
+  for(int i=0;i<size;i++){
+    arr[i] = rand() % 117;
+  }
+  return arr; 
 }
 
 int height(TreeNode * root) {
-  return 0; 
+  if(root == NULL)
+    return 0;
+  return max(height(root->left),height(root->right)) + 1;
+  
+}
+void inorder(TreeNode* root){
+  if(root==NULL)
+    return;
+  inorder(root->left);
+  cout<<root->val<<" ";
+  inorder(root->right);
+  return;
+}
+void preorder(TreeNode* root){
+  if(root == NULL)
+    return;
+  cout<<root->val<<" ";
+  preorder(root->left);
+  preorder(root->right);
+  return;
+}
+void postorder(TreeNode * root){
+  if(root == NULL)
+    return;
+  postorder(root->left);
+  postorder(root->right);
+  cout<<root->val<<" ";
+  return;
 }
-
 void printTraversals(TreeNode * root) {
   // print inorder
+  cout<<"Inorder"<<endl;
+  inorder(root);
+  cout<<endl;
   // print preorder
+  cout<<"Preorder"<<endl;
+  preorder(root);
+  cout<<endl;
   // print postorder
+  cout<<"Postorder"<<endl;
+  postorder(root);
+  cout<<endl;
+  return;
 }
 
 
 // Return NULL if val not found. 
 TreeNode * search(TreeNode * root, int val) {
-  return NULL; 
+  if(root == NULL)
+    return root;
+  if(root->val == val)
+    return root;
+  if(root->val > val)
+    return search(root->left, val);
+  
+  return search(root->right, val); 
 }
 
 // Return parent even if val is not present in tree. 
 // Basically return the parent of the location where val should have been.
 TreeNode* searchParent(TreeNode * root, int val) {
-  return NULL; 
+  if(root == NULL)
+    return root;
+  
+  if(root->left != NULL and root->left->val == val)
+    return root;
+  if(root->right != NULL and root->right->val == val)
+    return root;
+  if(root->val>val)
+    return searchParent(root->left,val);
+  return searchParent(root->right,val);
 }
 
 
 TreeNode * insert(TreeNode * root, int val) {
-  return root; 
+  if (root == NULL) {
+      TreeNode* t=new TreeNode(val); 
+      return t;
+    }
+ 
+    
+    if (val< root->val) {
+        root->left = insert(root->left, val);
+    }
+    else {
+        root->right = insert(root->right, val);
+    }
+ 
+    return root;
+
+
 }
  
 int maxValue(TreeNode * root) {
-  return INT_MAX; 
+  if(root->right == NULL)
+    return root->val;
+  
+  return maxValue(root->right); 
 }
 
 int minValue(TreeNode * root) {
-  return INT_MIN; 
+  if(root->left == NULL)
+    return root->val;
+  
+  return minValue(root->left);
 }
 
 // Return NULL if val has no successor, ie, val is greater than maxValue(root);  
 // Successor should be returned even if val is not present in the tree. 
-TreeNode * findSuccessor(TreeNode * root) {
-  return NULL;
+TreeNode * findSuccessor(TreeNode * root,TreeNode* Root) {
+  
+  if(root == NULL)
+  { return root;}
+  if(root->right)
+    return search(root->right,minValue(root->right));
+  TreeNode * t = searchParent(Root,root->val);
+  while( t!=NULL and root == t->right){
+    root = t;
+    t = searchParent(Root,root->val);
+  }
+  return t;
 }
 
 // Return NULL if val has no predecessor, ie, val is smaller than minValue(root);  
 // Predecessor should be returned even if val is not present in the tree. 
-TreeNode * findPredecessor(TreeNode * root) {
-  return NULL;
+TreeNode * findPredecessor(TreeNode * root,TreeNode* Root) {
+  if(root == NULL)
+    return root;
+  if(root->left)
+    return search(root->left,maxValue(root->left));
+  TreeNode * t = searchParent(Root,root->val);
+  while( t!=NULL and root == t->left){
+    root = t;
+    t = searchParent(Root,root->val);
+  }
+  return t;
 }
 
 // First generate random array. Then build this tree by calling insert() on each element of array. 
 TreeNode * buildTree(vector<int> & v) {
   // Call insert() repeatedly to build the tree.
-  TreeNode * root = new TreeNode(); 
-  return root; 
+  TreeNode* root = NULL;
+  for(auto it:v)
+  { 
+    root = insert(root,it);
+  }
+  return root;
 }
+void LevelOrderBFS(TreeNode* root){
+  if(root == NULL)
+    return ;
+  queue<TreeNode*> q;
+  q.push(root);
+  q.push(NULL);
+  while(!q.empty()){
+    TreeNode* temp = q.front();
+    q.pop();
+    if(temp == NULL)
+    {
+      cout<<"\n";
+      if(!q.empty())
+        q.push(NULL);
+    }
+    else{
+      cout<<temp->val<<" ";
+      if(temp->left)
+        q.push(temp->left);
+      if(temp->right)
+        q.push(temp->right);
 
+    }
+    
+  }
+  return;
+}
 
 
 int main() {
@@ -80,20 +216,51 @@ int main() {
   // https://www.youtube.com/watch?v=K6nw5TvhX2s&list=PLrYpW0KwQ3sMemsZOzhawxMpFet3Hb3SN&index=39
 
   // 1. Generate a random array. 
-  // 2. Create an empty tree and insert one value from the array at a time. 
-  // 3. Inorder traversal of this binary search tree should be equal to the sorted value of random array.   
+  vector<int> arr = generateRandomArray(10);
+  for(auto it:arr)
+    cout<<it<<" ";
+  cout<<"\n";
+  // 2. Create an empty tree and insert one value from the array at a time.
+  TreeNode* root = buildTree(arr);
+   
+  // 3. Inorder traversal of this binary search tree should be equal to the sorted value of random array.  
+  printTraversals(root); 
   // 4. Find the height of the tree. 
+  // Level order
+  cout<<"Level Order"<<"\n";
+  LevelOrderBFS(root);
+  cout<<"Height of tree : "<< height(root)<<" \n";
   
-  
-  // 5. Find the minimum value in the array. 
+  // 5. Find the minimum value in the array.
+  int mv = minValue(root); 
+  cout<<"Min value in tree : "<<mv<<"\n";
   // 6. In the tree, find successor of this value. Print it. Then find successor
+  TreeNode * temp = search(root,mv);
+  
+  TreeNode * succ = findSuccessor(temp,root);
+  
+  while(succ != NULL){
+  cout<<"successor of "<<temp->val<<" is "<<succ->val<<" \n";
+  temp = succ;
+  succ = findSuccessor(temp,root);
+  }
+
   //    of the value just obtained. Print again and so on. 
   // 7. This list should be equal to the sorted value of the array. 
   
   // 8. Find the maximum value in the array. 
+  int mx = maxValue(root);
+  cout<<"Max value in tree : "<<mx<<"\n";
   // 9. In the tree, find predecessor of this value. Print it. Then find predecessor
   //    of the value just obtained till no more predecessor exists. Print again and so on. 
   // 10. This list should be equal to the sorted value of the array. 
+  temp = search(root,mx);
+  TreeNode * psucc = findPredecessor(temp,root);
+  while(psucc != NULL){
+  cout<<"Presuccessor of "<<temp->val<<" is "<<psucc->val<<" \n";
+  temp = psucc;
+  psucc = findPredecessor(temp,root);
+  }
   
   
 }
diff --git a/drivercode/graphdriver b/drivercode/graphdriver
new file mode 100755
index 0000000..6afcdc0
Binary files /dev/null and b/drivercode/graphdriver differ
diff --git a/drivercode/graphdriver.cpp b/drivercode/graphdriver.cpp
index 76edb5d..f5cfe6c 100644
--- a/drivercode/graphdriver.cpp
+++ b/drivercode/graphdriver.cpp
@@ -1,57 +1,230 @@
 #include<iostream>
+#include<stdio.h>
 #include<fstream>
 #include<vector> 
+#include<queue>
+#include<algorithm>
+#include <climits>
 
 using namespace std; 
 
 class Graph {
   public:
+  bool bi = false;
+  int N;
+  int E;
   
-  int N; 
   vector<vector<int>> adj; // adjacency matrix. 
+  vector<vector<int>> edges; // weighted adjacency matrix
   
-  Graph(int nodes) {
+  Graph(int nodes,bool dir,int m) {
     N = nodes;
-    adj.resize(N, vector<int> ()); 
+    adj.resize(N, vector<int> ());
+    bi = dir;
+    E = m;
   }
   
   // Directed graph. Make sure nodes are zero indexed. 
   void addEdge(int u, int v) {
-    
+    adj[u].push_back(v);
+    if(bi)
+      adj[v].push_back(u);
+  }
+
+  // added wieghted edge
+  void addEdgeW(int u, int v, int w){
+    edges.push_back({u,v,w});
   }
   
   // Write BFS Code. 
   void bfs(int start) {
+    queue<int> q; 
+    q.push(start);
+    vector<bool> visited(N,false);
+    while(!q.empty()){
+      
+      int v = q.front();
+      visited[v] = true;
+      q.pop();
+      for(auto nbr : adj[v]){
+        if(visited[nbr] == true)
+            continue;
+          cout<<v<<" "<<nbr<<endl;
+        q.push(nbr);
+      }
+
+    }
+
+    return;
   }
 
   // Print shortest path from start node to end node.  
   void printBfsPath(int start, int end) {
+    vector<int> parent (N,-1);
+    parent[start] = start;
+    vector<bool> vis(N,false);
+    queue<int> q;
+    q.push(start);
+    while(!q.empty()){
+      int u = q.front();
+      q.pop();
+      vis[u] = true;
+      for(int v:adj[u]){
+        if(!vis[v]){
+          parent[v] = u;
+          q.push(v);
+        }
+
+      }
+    }
+
+    while(parent[end] != end){
+      cout<<end<<" -> ";
+      end = parent[end];
+    }
+    cout<<end<<endl;
+    return;
   }
   
   // use bfs.
   vector<int> getShortestDistanceToAllNodes(int start) {
+    vector<int> dis(N,-1);
+    dis[start] = 0;
+    queue<int> q;
+    q.push(start);
+    vector<bool> vis(N);
+    while(!q.empty()){
+      int u = q.front();
+      q.pop();
+      vis[u] = true;
+      for(int nbr: adj[u]){
+        if(vis[nbr]) continue;
+        if(dis[nbr]==-1) dis[nbr] = dis[u]+1;
+        q.push(nbr);
+      }
+    }
+  return dis;
+
   }
   
   // Why dfsForest? Because the graph may not be connected. 
   void dfsForest(int start) {
+    vector<bool> vis(N);
+    for(int i=0;i<N;i++){
+      if(!vis[i]){
+
+        dfsTree(i,vis);
+        cout<<endl;
+      }
+    }
   }
   
   // This is the actual method that will be called recursively for dfs exploration. 
-  void dfsTree(int start) {
+  void dfsTree(int start, vector<bool> &vis) {
+    if(vis[start]){
+      return;
+    }
+    vis[start] = true;
+    cout<<start<<" ";
+    for(int v: adj[start]){
+      if(vis[start]) continue;
+      dfsTree(v,vis);
+    }
+    return ;
   }
   
   // Solve using dfs (or any other method you know). 
+  bool dfsCyclic(int start,int parent , vector<int> &vis){
+    vis[start] = true;
+    for(int nbr : adj[start]){
+      if(!vis[nbr]){
+        bool t = dfsCyclic(nbr, start, vis);
+        if(t)
+          return t;
+      }
+      else if(nbr!=parent){
+          return true;
+      }
+    }
+
+    return false;
+  }
   bool isCyclic() {
+      vector<int> vis(N);
+      for(int i=0;i<N;i++){
+        if(!vis[i])
+        {
+          bool cycle = dfsCyclic(i,-1,vis);
+          if(cycle) return true;
+        }
+      }
+    return false;
   }
   
   // Return vector with all nodes in topological order. If not possible, return empty vector. 
+  void topoSort(int start, vector<bool> &vis, vector<int> &topoStack){
+    vis[start] = true;
+    for(auto nbr: adj[start]){
+      if(!vis[nbr]) topoSort(nbr,vis,topoStack);
+    }
+    topoStack.push_back(start);
+    return ;
+  }
   vector<int> topologicalSort() {
+    vector<bool> vis(N);
+    vector<int> topoStack;
+    for(int i=0;i<N;i++){
+      if(!vis[i])
+        topoSort(i,vis,topoStack);
+    }
+    reverse(topoStack.begin(),topoStack.end());
+    return topoStack;
   }
   
   // For implementation, this is the best shortest path algorithm to implement. Djikstra is difficult to implement. 
   // For an unweighted graph, compare the output of this with the BFS algorithm. 
   // Return shortest path to all nodes. 
   vector<int> bellmanFord(int start) {
+    vector<int> d(N,INT_MAX);
+    d[start] = 0;
+    vector<int> parent(N,-1);
+    parent[start] = start;
+    for(int i=0;i<N;i++){
+      for(int j=0;j<E;j++){
+        int u = edges[j][0];
+        int v = edges[j][1];
+        int w = edges[j][2];
+        if(d[u] != INT_MAX and d[u] + w < d[v])
+        {  d[v] = d[u] + w;
+          parent[v] = u;
+        }
+      }
+    }
+
+    for(int j=0;j<E;j++)
+    {
+        int u = edges[j][0];
+        int v = edges[j][1];
+        int w = edges[j][2];
+        if(d[u] != INT_MAX and d[u] + w < d[v])
+        {
+          cout<<"There is a negative cycle in graph"<<endl;
+          return {};
+        }
+    }
+
+    for(int i=0;i<N;i++){
+      cout<<"Shortest Path from "<<start<<" to "<< i<<endl;
+      int end = i;
+      while(parent[end] != end){
+        cout<<end<<" -> ";
+        end = parent[end];
+      }
+      cout<<end<<endl;
+    }
+
+    return d;
+
   }
   
 };
@@ -63,11 +236,59 @@ int main() {
   // Read this edge list from the text file. 
   // Complete the methods above and run all methods on the graph you built in your text file. 
   // Try with disconnected graph, cyclic graph etc. 
- 
   
+  #ifndef checkmate
+    freopen("input.txt","r",stdin);
+    freopen("output.txt","w",stdout);
+  #endif
+  int n; cin>>n;
+  int m; cin>>m; 
+  // cout<<n<<endl;
+  Graph adj = Graph(n,true,m);
+  
+  for(int i=0;i<m;i++){
+    int u,v; cin>>u>>v;
+    adj.addEdge(u,v);
+  }
+
+  adj.bfs(0);
+  int source = 0;
+  cout<<"Distance of all nodes from "<<source<<endl;
+  vector<int> d = adj.getShortestDistanceToAllNodes(source);
+  for(int i=0;i<d.size();i++){
+    cout<<source<<" "<<i<<" = "<<d[i]<<endl;
+  }
+  adj.printBfsPath(0, 4);
+  cin>>n>>m;
+  Graph g = Graph(n,false,m);
+  for(int i=0;i<m;i++){
+    int u,v; cin>>u>>v;
+    g.addEdge(u,v);
+  }
+  vector<int> topo = g.topologicalSort();
+  cout<<"Topological Sorting"<<endl;
+  for(auto it:topo)
+    cout<<it<<" ";
+  cout<<endl;
   // Read text files using ifstream. You can refer learncpp.com for this.
   
   // Assignment 2: 
   // Now add weights to your edges and read the weighted graph in your adjacency matrix. 
   // Run bellman ford algorithm to print shortest paths. 
+  cin>>n>>m;
+  Graph graphW = Graph(n,false,m);
+  for(int i=0;i<m;i++){
+    int u,v,w; cin>>u>>v>>w;
+    graphW.addEdgeW(u,v,w);
+  }
+  
+  vector<int>wd = graphW.bellmanFord(0);
+  for(int i=0;i<wd.size();i++){
+    cout<<"Distance from "<<source<<" to "<<i<<" = "<<wd[i]<<endl;
+  }
+
+
+
+
+  
 }
diff --git a/drivercode/input.txt b/drivercode/input.txt
new file mode 100644
index 0000000..2ccd58e
--- /dev/null
+++ b/drivercode/input.txt
@@ -0,0 +1,22 @@
+5 4
+0 1
+1 2 
+2 3
+3 4
+
+6 5
+0 1 
+0 2 
+2 4 
+3 5 
+4 5
+
+5 5
+0 1 2
+2 4 3
+1 2 -1
+4 3 100
+1 3 -3
+
+
+
diff --git a/drivercode/linked_list_sol.cpp b/drivercode/linked_list_sol.cpp
new file mode 100644
index 0000000..ea3a11b
--- /dev/null
+++ b/drivercode/linked_list_sol.cpp
@@ -0,0 +1,220 @@
+// Linkedlist Driver Code 
+
+// Write include statements. 
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// Linkedlist node
+class Node {
+  public: 
+  int val; 
+  Node * next; 
+  Node () {
+    this->next = NULL; 
+  }
+  Node(int val) {
+    this->val = val; 
+    this->next = NULL; 
+  }
+}; 
+
+
+// Print linked list 
+void printList(Node *head) {
+    while(head != NULL){
+        cout<<head->val<<" ";
+        head = head->next;
+    }
+    cout<<endl;
+}
+
+
+// Return an array of random integers of the given size. 
+vector<int> generateRandomArray(int size ){
+    vector<int> arr(size);
+    for(int i=1;i<=size;i++){
+        arr[i-1] = rand() % 117;
+    }
+    sort(arr.begin(),arr.end());
+  return arr; 
+}
+
+
+// Convert array to linkedlist
+Node * convertArrayToLinkedList(vector<int> & v) {
+    
+   Node* head =new Node();
+   Node* temp = head;
+   for(auto it:v){
+       Node * temp = new Node(it);
+       head->next = temp;
+       head = head->next;
+   } 
+   return temp->next;
+}
+
+
+
+// Insert into a linked list at given position. Position = 1 means insert before head. 
+Node * insertNode (Node * head, int val, int position) {
+    if(position == 1 ){
+        Node* temp = new Node(val);
+        temp->next = head;
+        head = temp;
+        return head;
+    }
+    int cnt = 1;
+    Node * temp = head;
+    while(cnt!=position-1){
+        temp = temp->next;
+        cnt++;
+
+    }
+    Node* temp2 = new Node(val);
+    temp2->next = temp->next;
+    temp->next = temp2;
+
+    
+
+  return head; 
+}
+
+
+// Delete from a linked list. 
+Node *deleteNode (Node * head, int position) {
+    if(position == 1){
+        return head->next;
+    }
+    if(head->next == NULL){
+        Node *temp = new Node();
+        return temp;
+    }
+    int cnt = 1;
+    Node * temp = head;
+    while(cnt != position-1){
+        temp = temp->next;
+        cnt++;
+    }
+    temp->next = temp->next->next;
+
+
+ return head; 
+}
+
+
+// Compare linkedlists. 
+bool areEqual(Node *head1, Node * head2) {
+    while(head1 != NULL and head2 !=NULL){
+        if(head1->val != head2->val)
+            return false;
+        head1 = head1->next;
+        head2 = head2->next;
+    }
+    if(head1 != NULL or head2 !=NULL)
+        return false;
+  return true; 
+}
+
+// K = 1 means delete last node. 
+Node *deleteKthNodeFromEnd(Node * head, int k) {
+     Node * temp1 = head;
+     Node* temp2 = head;
+     
+     while(k-- and temp1!=NULL){
+         temp1 = temp1->next;
+     }
+     if(temp1 == NULL)
+        return head->next;
+     while(temp1->next != NULL){
+         temp2 = temp2->next;
+         temp1 = temp1->next;
+     }
+     temp2->next = temp2->next->next;
+
+  return head; 
+}
+
+
+
+// Reverse a linkedlist. 
+Node * reverseList(Node *head) {
+    Node * next = head;
+    Node* curr = head;
+    Node * prev = NULL;
+    while(curr != NULL){
+        next = curr->next;
+        curr->next = prev;
+        prev = curr;
+        curr = next;
+    }
+  return prev; 
+}
+
+// Merge sorted lists. 
+Node * mergeSortedLists(Node * head1, Node * head2) {
+        Node *h1 = head1;
+        if(head1->val < head2->val){
+            head1 = head1->next;
+        }
+        else{
+            h1 = head2;
+            head2 = head2->next;
+        }
+        Node* temp = h1;
+        while(head1 != NULL and head2 != NULL){
+            if(head1->val < head2->val){
+
+                h1->next = head1;
+                h1 = h1->next;
+                head1 = head1->next;
+            }
+            else{
+                h1->next = head2;
+                h1 = h1->next;
+                head2 = head2->next;
+            }
+        }
+        while(head1 != NULL){
+            h1->next = head1;
+            head1 = head1->next;
+            h1 = h1->next;
+        }
+        while(head2 != NULL){
+            h1->next = head1;
+            head2 = head2->next;
+            h1 = h1->next;
+        }
+
+return temp; 
+}
+
+int main() {
+  // 1. Get a random array. 
+  // 2. Convert array to LinkedList List1.
+  // 3. Insert a number at position P into the list.
+  // 4. Delete this number from position P. 
+  // 5. Create another linkedlist (List2) from the same random array. 
+  // 6. Compare that List1 is the same as List2. 
+
+  int size = 4;
+  vector<int> arr = generateRandomArray(size);
+  vector<int> arr2 = generateRandomArray(size+2);
+  Node *head =  convertArrayToLinkedList(arr);
+  Node *head2 =  convertArrayToLinkedList(arr2);
+//   printList(head);
+//   head = insertNode(head,312,11);
+//   printList(head);
+//   head = deleteNode(head,10);
+  printList(head);
+  printList(head2);
+//   printList(head2);
+//   cout<< areEqual(head,head2)<<endl;
+    // head = deleteKthNodeFromEnd(head, 10);
+    // printList(head);
+    // head = reverseList(head);
+    head2 = mergeSortedLists(head,head2);
+    printList(head2);
+  
+  
+}
\ No newline at end of file
diff --git a/drivercode/output.txt b/drivercode/output.txt
new file mode 100644
index 0000000..248af29
--- /dev/null
+++ b/drivercode/output.txt
@@ -0,0 +1,28 @@
+0 1
+1 2
+2 3
+3 4
+Distance of all nodes from 0
+0 0 = 0
+0 1 = 1
+0 2 = 2
+0 3 = 3
+0 4 = 4
+4 -> 3 -> 2 -> 1 -> 0
+Topological Sorting
+3 0 2 4 5 1 
+Shortest Path from 0 to 0
+0
+Shortest Path from 0 to 1
+1 -> 0
+Shortest Path from 0 to 2
+2 -> 1 -> 0
+Shortest Path from 0 to 3
+3 -> 1 -> 0
+Shortest Path from 0 to 4
+4 -> 2 -> 1 -> 0
+Distance from 0 to 0 = 0
+Distance from 0 to 1 = 2
+Distance from 0 to 2 = 1
+Distance from 0 to 3 = -1
+Distance from 0 to 4 = 4