Merge pull request #105 from nb9960/master

added Data-Structures in Cpp

Author: larissalages

data_structures/Cpp/Binary Trees/Traversal/a.out

@@ -0,0 +1,76 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class node
+{
+public:
+  int data;
+  node* left, *right;
+};
+
+void printPreorder(node *root){
+  if(root==NULL)
+    return;
+  cout<<root->data<<" ";
+  printPreorder(root->left);
+  printPreorder(root->right);
+}
+
+void printInorder(node *root){
+  if(root==NULL)
+    return;
+  printInorder(root->left);
+  cout<<root->data<<" ";
+  printInorder(root->right);
+}
+
+void printPostorder(node *root){
+  if(root==NULL)
+    return;
+  printPostorder(root->left);
+  printPostorder(root->right);
+  cout<<root->data<<" ";
+}
+
+node* newNode(int data){
+  node* Node=new node();
+  Node->data=data;
+  Node->left=NULL;
+  Node->right=NULL;
+  return Node;
+}
+
+int main(){
+  node* root=newNode(1);
+  root->left=newNode(2);
+  root->right=newNode(3);
+  root->left->left=newNode(4);
+  root->left->right=newNode(5);
+
+  // root left right
+  cout<<"PreOrder: ";
+  printPreorder(root);
+  cout<<"\n";
+
+  // left root right
+  cout<<"InOrder: ";
+  printInorder(root);
+  cout<<"\n";
+
+  // left right root
+  cout<<"PostOrder: ";
+  printPostorder(root);
+  cout<<"\n";
+  return 0;
+}
+
+/*
+      1
+    /   \
+   2     3
+  /  \
+  4   5
+  Time complexity: worst case: O(n^2)
+  Space complexity: O(n) for worst case for skewed tree 
+                    For balanced tree O(logn)
+*/

data_structures/Cpp/Binary Trees/Traversal/depthFirst.cpp

@@ -0,0 +1,70 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class node
+{
+public:
+  int data;
+  node* left, *right;
+};
+
+void printGivenLevel(node* root, int level){
+  if(root==NULL)
+    return;
+  if(level==1)
+    cout<<root->data<<" ";
+  else if(level>1){
+    printGivenLevel(root->left,level-1);
+    printGivenLevel(root->right,level-1);
+  }
+}
+
+int height(node* node){
+  if(node==NULL)
+    return 0;
+  else{
+    int lheight=height(node->left);
+    int rheight=height(node->right);
+    if(lheight>rheight)
+      return (lheight+1);
+    else return (rheight+1);
+  }
+}
+
+node* newNode(int data){
+  node* Node=new node();
+  Node->data=data;
+  Node->left=NULL;
+  Node->right=NULL;
+  return Node;
+}
+
+void printLevelOrder(node *root){
+  int h=height(root);
+  int i;
+  for(i=1;i<=h;i++){
+    printGivenLevel(root,i);
+  }
+}
+
+int main(){
+  node* root=newNode(1);
+  root->left=newNode(2);
+  root->right=newNode(3);
+  root->left->left=newNode(4);
+  root->left->right=newNode(5);
+
+  printLevelOrder(root);
+  return 0;
+}
+
+/*
+      1
+    /   \
+   2     3
+  /  \
+  4   5
+  Time complexity: worst case: O(n^2)
+  Space complexity: O(n) for worst case for skewed tree 
+                    For balanced tree O(logn)
+*/

data_structures/Cpp/Binary Trees/Traversal/levelOrder.cpp

@@ -0,0 +1,55 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class node
+{
+public:
+  int data;
+  node* left, *right;
+};
+
+node* newNode(int data){
+  node* Node=new node();
+  Node->data=data;
+  Node->left=NULL;
+  Node->right=NULL;
+  return Node;
+}
+
+void printLevelOrder(node *root){
+  if(root==NULL)
+    return;
+  queue<node *> q;
+  q.push(root);
+  while(q.empty()==false){
+    node *Node=q.front();
+    cout<<Node->data<<" ";
+    q.pop();
+    if(Node->left!=NULL)
+      q.push(Node->left);
+    if(Node->right!=NULL)
+      q.push(Node->right);
+  }
+  
+}
+
+int main(){
+  node* root=newNode(1);
+  root->left=newNode(2);
+  root->right=newNode(3);
+  root->left->left=newNode(4);
+  root->left->right=newNode(5);
+
+  printLevelOrder(root);
+  return 0;
+}
+
+/*
+      1
+    /   \
+   2     3
+  /  \
+  4   5
+  Time complexity: O(n)
+  Space complexity: O(n) 
+*/

data_structures/Cpp/Binary Trees/Traversal/levelOrderQ.cpp

@@ -0,0 +1,59 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class node
+{
+public:
+  int data;
+  node* left, *right;
+};
+
+bool sameTree(node *tree1,node* tree2){
+  if(tree1==NULL && tree2==NULL){
+    return 1;
+  }
+  if(tree1!=NULL && tree2!=NULL){
+    return(tree1->data==tree2->data && sameTree(tree1->left, tree2->left) && sameTree(tree1->right,tree2->right));
+  }
+  return 0;
+}
+
+node* newNode(int data){
+  node* Node=new node();
+  Node->data=data;
+  Node->left=NULL;
+  Node->right=NULL;
+  return Node;
+}
+
+int main(){
+  node* root1=newNode(1);
+  root1->left=newNode(2);
+  root1->right=newNode(3);
+  root1->left->left=newNode(4);
+  root1->left->right=newNode(5);
+
+  node* root2=newNode(1);
+  root2->left=newNode(2);
+  root2->right=newNode(5);
+  root2->left->left=newNode(4);
+  root2->left->right=newNode(5);
+
+  if(sameTree(root1,root2)==0){
+    cout<<"NOT IDENTICAL"<<endl;
+  }else{
+    cout<<"Identical"<<endl;
+  }
+  return 0;
+}
+
+/*
+      1
+    /   \
+   2     3
+  /  \
+  4   5
+  Time complexity: worst case: O(n^2)
+  Space complexity: O(n) for worst case for skewed tree 
+                    For balanced tree O(logn)
+*/

data_structures/Cpp/Binary Trees/a.out

@@ -0,0 +1,69 @@
+// Author:Nishtha
+#include <bits/stdc++.h> 
+using namespace std; 
+
+class node
+{
+public:
+  int key_value;
+  node* left, *right;
+};
+
+// node* newNode(int data){
+//   node* Node=new node();
+//   Node->data=data;
+//   Node->left=NULL;
+//   Node->right=NULL;
+//   return Node;
+// }
+
+void insert(int key, node *leaf)
+{
+  if(key< leaf->key_value)
+  {
+    if(leaf->left!=NULL)
+     insert(key, leaf->left);
+    else
+    {
+      leaf->left=new node;
+      leaf->left->key_value=key;
+      leaf->left->left=NULL;    //Sets the left child of the child node to null
+      leaf->left->right=NULL;   //Sets the right child of the child node to null
+    }  
+  }
+  else if(key>=leaf->key_value)
+  {
+    if(leaf->right!=NULL)
+      insert(key, leaf->right);
+    else
+    {
+      leaf->right=new node;
+      leaf->right->key_value=key;
+      leaf->right->left=NULL;  //Sets the left child of the child node to null
+      leaf->right->right=NULL; //Sets the right child of the child node to null
+    }
+  }
+}
+
+// Drive Code 
+int main() 
+{  
+  cout<<"Enter the no. of numbbers to be entered:"<<endl;
+  int n;cin>>n;
+  cout<<"Enter numbers:";
+  node* root=NULL;
+  for(int i=0;i<n;i++){
+    int x;cin>>x;
+    if(root!=NULL)
+    insert(x, root);
+    else
+    {
+      root=new node;
+      root->key_value=x;
+      root->left=NULL;
+      root->right=NULL;
+    }
+  }
+
+  return 0; 
+}