diff --git a/BINARY TREE Diameter Of a Tree Optimized Approach b/BINARY TREE Diameter Of a Tree Optimized Approach
new file mode 100644
index 0000000..73242b6
--- /dev/null
+++ b/BINARY TREE Diameter Of a Tree Optimized Approach	
@@ -0,0 +1,61 @@
+#include <iostream>
+#include<queue>
+using namespace std;
+class node{
+    public:
+        int data;
+        node*left;
+        node*right;
+
+        node(int d){
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+node* buildTree(){
+    int d;
+    cin>>d;
+
+    if(d==-1){
+        return NULL;
+    }
+    node * root = new node(d);
+    root->left = buildTree();
+    root->right = buildTree();
+    return root;
+}
+class Pair{
+    public:
+        int height;
+        int diameter;
+};
+
+Pair fastDiameter(node*root){
+    Pair p;
+    if(root==NULL){
+        p.diameter = p.height = 0;
+        return p;
+    }
+    //Otherwise
+    Pair left = fastDiameter(root->left);
+    Pair right = fastDiameter(root->right);
+
+    p.height = max(left.height,right.height) + 1;
+    p.diameter = max(left.height+right.height, max(left.diameter,right.diameter));
+    return p;
+}
+
+int main(){ 
+    node* root = buildTree();
+    Pair p = fastDiameter(root);
+    cout<<p.height<<endl;
+    cout<<p.diameter<<endl;
+    return 0;
+}
+/* i/p:
+     8 10 7 -1 -1 6 9 -1 -1 7 -1 -1 3 -1 14 13 -1 -1 -1
+   i/p:
+     4
+     6
+     */
diff --git a/Binary Search Tree/Add_node_in_BST.cpp b/Binary Search Tree/Add_node_in_BST.cpp
new file mode 100644
index 0000000..66efd6f
--- /dev/null
+++ b/Binary Search Tree/Add_node_in_BST.cpp	
@@ -0,0 +1,117 @@
+#include <iostream>
+#include<queue>
+using namespace std;
+
+class node{
+    public:
+        int data;
+        node*left;
+        node*right;
+
+        node(int d){
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+
+//Accepts the old root node & data and returns the new root node 
+node* insertinBST(node *root,int data){
+    //Base Case
+    if(root==NULL){
+        return new node(data);
+    }
+    //Rec Case - Insert in the Subtree and Update Pointers
+    if(data<=root->data){
+        root->left = insertinBST(root->left,data);
+    }
+    else{
+        root->right = insertinBST(root->right,data);
+    }
+    return root;
+}
+
+bool search(node*root,int data){
+    if(root==NULL){
+        return false;
+    }
+    if(root->data==data){
+        return true;
+    }
+    //Recursively search in left and right subtree
+    if(data<=root->data){
+        return search(root->left,data);
+    }
+    else{
+        return search(root->right,data);
+    }
+}
+
+node* build(){
+    //Read a list of numbers till -1 and also these numbers will be inserted into BST
+    int d;
+    cin>>d;
+
+    node*root = NULL;
+
+    while(d!=-1){
+        root = insertinBST(root,d);
+        cin>>d;
+    }
+    return root;
+}
+//Print the BST Level By Level
+void bfs(node *root){
+    queue<node*> q;
+    q.push(root);
+    q.push(NULL);
+
+    while(!q.empty()){
+        node* f = q.front();
+        if(f==NULL){
+            cout<<endl;
+            q.pop();
+            if(!q.empty()){
+                q.push(NULL);
+            }
+        }
+        else{
+            cout<<f->data<<",";
+            q.pop();
+
+            if(f->left){
+                q.push(f->left);
+            }
+            if(f->right){
+                q.push(f->right);
+            }
+        }
+    }
+    return;
+}
+node* add(node* root,int data)
+{
+	if(root==NULL)
+	{
+		return new node(data);
+	}
+	if(data<=root->data)
+	{
+		root->left=add(root->left,data);
+	}
+	if(data>=root->data)
+	{
+		root->right=add(root->right,data);
+	}
+	return root;
+}
+int main()
+{
+	node*root=build();
+	bfs(root);
+	int data;
+	cin>>data;
+	add(root,data);
+	cout<<endl;
+	bfs(root);
+}
diff --git a/Binary Search Tree/BST Check For BST.cpp b/Binary Search Tree/BST Check For BST.cpp
new file mode 100644
index 0000000..2ef6ffc
--- /dev/null
+++ b/Binary Search Tree/BST Check For BST.cpp	
@@ -0,0 +1,129 @@
+#include<iostream>
+#include<queue>
+#include<climits>
+using namespace std;
+class node
+{
+	public:
+	    int data;
+		node*left;
+		node*right;
+		node(int d)
+		{
+			data=d;
+			left=NULL;
+			right=NULL;
+		}	
+};
+bool isBST(node* root ,int minV=INT_MIN, int maxV=INT_MAX)
+{
+	if(root==NULL)
+	{
+		return true;
+	}
+	if(root->data>=minV and root->data<=maxV and isBST(root->left,minV,root->data) and isBST(root->right,root->data,maxV))
+	{
+		return true;
+	}
+	else
+	{
+	return false;
+    }
+}
+node* insertinBST(node*root,int data)    //Accepts the old root node & data & returns the new node
+{
+	if(root==NULL)                   //base case
+	{
+		return new node(data);
+	}
+    if(data<=root->data)
+    {
+    	root->left=insertinBST(root->left,data);
+	}
+	else
+	{
+		root->right=insertinBST(root->right,data);
+	}
+	return root;
+}
+node*build()     //Read a list of numbers till -1 and also these numbers will be inserted in the BST
+{
+	int d;
+	cin>>d;
+	node*root=NULL;
+	while(d!=-1) // as -1 encountered insertion stops
+	{
+		root=insertinBST(root,d);
+		cin>>d;
+	}
+	return root;
+}
+void bfs(node*root)        //to print the tree 
+{
+	queue<node*>q;
+	q.push(root);
+	q.push(NULL);
+	while(!q.empty())
+	{
+		node*f=q.front();
+		if(f==NULL)
+		{
+			cout<<endl;
+			q.pop();
+			if(!q.empty())
+			{
+				q.push(NULL); 
+			}
+		}
+		else
+		{
+			cout<<f->data<<",";
+			q.pop();
+			if(f->left)
+			{
+				q.push(f->left);
+			}
+			if(f->right)
+			{
+				q.push(f->right); 
+			}
+		}
+	}
+	return ;
+}
+void inorder(node*root)     //printing left, root then right
+{
+	if(root==NULL)
+	{
+		return;
+	}
+	inorder(root->left);
+	cout<<root->data<<",";
+	inorder(root->right);
+}
+int main()
+{
+	node*root=build();
+	inorder(root);
+	cout<<endl;
+	bfs(root);
+	cout<<endl;
+	if(isBST(root))
+	{
+		cout<<"yes it's a BST";
+	}
+	else
+	{
+		cout<<"Not a BST!!";
+	}
+	return 0;
+}
+/*
+i/p:
+  5 3 7 1 6 8 -1
+o/p:
+ 1,3,5,6,7,8,
+ 5,
+ 3,7,
+ 1,6,8,
+*/
diff --git a/Binary Search Tree/BST Deletion.cpp b/Binary Search Tree/BST Deletion.cpp
new file mode 100644
index 0000000..4455d19
--- /dev/null
+++ b/Binary Search Tree/BST Deletion.cpp	
@@ -0,0 +1,157 @@
+#include <iostream>
+#include<queue>
+using namespace std;
+
+class node{
+    public:
+        int data;
+        node*left;
+        node*right;
+
+        node(int d){
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+
+//Accepts the old root node & data and returns the new root node 
+node* insertInBST(node *root,int data){
+    //Base Case
+    if(root==NULL){
+        return new node(data);
+    }
+    //Rec Case - Insert in the Subtree and Update Pointers
+    if(data<=root->data){
+        root->left = insertInBST(root->left,data);
+    }
+    else{
+        root->right = insertInBST(root->right,data);
+    }
+    return root;
+}
+node* build(){
+    //Read a list of numbers till -1 and also these numbers will be inserted into BST
+    int d;
+    cin>>d;
+
+    node*root = NULL;
+
+    while(d!=-1){
+        root = insertInBST(root,d);
+        cin>>d;
+    }
+    return root;
+}
+//Print the BST Level By Level
+void bfs(node *root){
+    queue<node*> q;
+    q.push(root);
+    q.push(NULL);
+
+    while(!q.empty()){
+        node* f = q.front();
+        if(f==NULL){
+            cout<<endl;
+            q.pop();
+            if(!q.empty()){
+                q.push(NULL);
+            }
+        }
+        else{
+            cout<<f->data<<",";
+            q.pop();
+
+            if(f->left){
+                q.push(f->left);
+            }
+            if(f->right){
+                q.push(f->right);
+            }
+        }
+    }
+    return;
+}
+
+node* deleteinBST(node*root,int data)
+{
+	if(root==NULL)
+	{
+		return NULL;
+	}
+	else if(data<root->data)
+	{
+		root->left=deleteinBST(root->left,data);
+		return root;
+	}
+	else if(data==root->data)
+	{
+		//1.node with 0 child- LEAF NODE
+		if(root->left==NULL and root->right==NULL)
+		{
+			delete root;
+			return root;
+		}
+		//2.node with 1 child
+		if(root->left!=NULL and root->right==NULL)       //no right child
+		{
+			node*temp=root->left;      //storing the left subtree in temp
+			delete root;               //then deleting the root
+			return temp;               //returning the left subtree root to the node above the deleted root node
+		}
+		if(root->right!=NULL and root->left==NULL)      //no left child
+		{
+			node*temp=root->right;
+			delete root;
+			return temp;
+		}
+		//3.node with 2 children***special case
+		node* replace= root->right;
+		//find the inorder successor from right subtree
+		while(replace->left!=NULL)      //since the left of the sunbtree is balanced no change is needed. root is replaced with the right subtree's left or the last element 
+		{                                 //that is taking the pointer to shortest element of right subtree and then
+			replace=replace->left;      
+		}	
+		root->data=replace->data;
+		root->right=deleteinBST(root->right,replace->data);
+		return root;
+	}
+	else
+	{
+		root->right=deleteinBST(root->right,data);
+		return root;
+	}
+}
+//Inorder Print
+void inorder(node*root)
+{
+    if(root==NULL){
+        return;
+    }
+    inorder(root->left);
+    cout<<root->data<<",";
+    inorder(root->right);
+}
+int main()
+{
+	node*root=build();
+    inorder(root);
+	int d;
+	cin>>d;
+	root=deleteinBST(root,d);
+	inorder(root);
+	cout<<endl;
+	bfs(root);
+	return 0;
+}
+/*
+i/p:
+  5 3 7 1 6 8 -1
+o/p:
+1,3,5,6,7,8,
+3
+1,5,6,7,8,
+5,
+1,7,
+6,8,
+*/
diff --git a/Binary Search Tree/BST Insertion and Build.cpp b/Binary Search Tree/BST Insertion and Build.cpp
new file mode 100644
index 0000000..0c6651c
--- /dev/null
+++ b/Binary Search Tree/BST Insertion and Build.cpp	
@@ -0,0 +1,104 @@
+#include<iostream>
+#include<queue>
+using namespace std;
+class node
+{
+	public:
+	    int data;
+		node*left;
+		node*right;
+		node(int d)
+		{
+			data=d;
+			left=NULL;
+			right=NULL;
+		}	
+};
+node* insertinBST(node*root,int data)    //Accepts the old root node & data & returns the new node
+{
+	if(root==NULL)                   //base case
+	{
+		return new node(data);
+	}
+    if(data<=root->data)
+    {
+    	root->left=insertinBST(root->left,data);
+	}
+	else
+	{
+		root->right=insertinBST(root->right,data);
+	}
+	return root;
+}
+node*build()     //Read a list of numbers till -1 and also these numbers will be inserted in the BST
+{
+	int d;
+	cin>>d;
+	node*root=NULL;
+	while(d!=-1) // as -1 encountered insertion stops
+	{
+		root=insertinBST(root,d);
+		cin>>d;
+	}
+	return root;
+}
+void bfs(node*root)        //to print the tree 
+{
+	queue<node*>q;
+	q.push(root);
+	q.push(NULL);
+	while(!q.empty())
+	{
+		node*f=q.front();
+		if(f==NULL)
+		{
+			cout<<endl;
+			q.pop();
+			if(!q.empty())
+			{
+				q.push(NULL); 
+			}
+		}
+		else
+		{
+			cout<<f->data<<",";
+			q.pop();
+			if(f->left)
+			{
+				q.push(f->left);
+			}
+			if(f->right)
+			{
+				q.push(f->right); 
+			}
+		}
+	}
+	return ;
+}
+void inorder(node*root)     //printing left, root then right
+{
+	if(root==NULL)
+	{
+		return;
+	}
+	inorder(root->left);
+	cout<<root->data<<",";
+	inorder(root->right);
+}
+int main()
+{
+	node*root=build();
+	inorder(root);
+	cout<<endl;
+	bfs(root);
+	return 0;
+}
+/*
+i/p:
+  5 3 7 1 6 8 -1
+o/p:
+ 1,3,5,6,7,8,
+ 5,
+ 3,7,
+ 1,6,8,
+*/
diff --git a/Binary Search Tree/BST Searching.cpp b/Binary Search Tree/BST Searching.cpp
new file mode 100644
index 0000000..c5aaf88
--- /dev/null
+++ b/Binary Search Tree/BST Searching.cpp	
@@ -0,0 +1,129 @@
+#include <iostream>
+#include<queue>
+using namespace std;
+
+class node{
+    public:
+        int data;
+        node*left;
+        node*right;
+
+        node(int d){
+            data = d;
+            left = NULL;
+            right = NULL;
+        }
+};
+
+//Accepts the old root node & data and returns the new root node 
+node* insertinBST(node *root,int data){
+    //Base Case
+    if(root==NULL){
+        return new node(data);
+    }
+    //Rec Case - Insert in the Subtree and Update Pointers
+    if(data<=root->data){
+        root->left = insertinBST(root->left,data);
+    }
+    else{
+        root->right = insertinBST(root->right,data);
+    }
+    return root;
+}
+
+bool search(node*root,int data){
+    if(root==NULL){
+        return false;
+    }
+    if(root->data==data){
+        return true;
+    }
+    //Recursively search in left and right subtree
+    if(data<=root->data){
+        return search(root->left,data);
+    }
+    else{
+        return search(root->right,data);
+    }
+}
+
+node* build(){
+    //Read a list of numbers till -1 and also these numbers will be inserted into BST
+    int d;
+    cin>>d;
+
+    node*root = NULL;
+
+    while(d!=-1){
+        root = insertinBST(root,d);
+        cin>>d;
+    }
+    return root;
+}
+//Print the BST Level By Level
+void bfs(node *root){
+    queue<node*> q;
+    q.push(root);
+    q.push(NULL);
+
+    while(!q.empty()){
+        node* f = q.front();
+        if(f==NULL){
+            cout<<endl;
+            q.pop();
+            if(!q.empty()){
+                q.push(NULL);
+            }
+        }
+        else{
+            cout<<f->data<<",";
+            q.pop();
+
+            if(f->left){
+                q.push(f->left);
+            }
+            if(f->right){
+                q.push(f->right);
+            }
+        }
+    }
+    return;
+}
+//Inorder Print
+void inorder(node*root){
+    if(root==NULL){
+        return;
+    }
+    inorder(root->left);
+    cout<<root->data<<",";
+    inorder(root->right);
+}
+int main()
+{
+	node*root=build();
+	inorder(root);
+	cout<<endl;
+	bfs(root);
+	int s;
+	cin>>s;
+	if(search(root,s))
+	{
+		cout<<"Present!!";
+	}
+	else
+	{
+		cout<<"Not Present";
+	}
+	return 0;
+}
+/*
+i/p:
+5 3 7 1 6 8 -1
+5
+o/p:
+1,3,5,6,7,8,
+5,
+3,7,
+1,6,8,
+Present!!
+*/
diff --git a/Binary Search Tree/BST To Sorten Linked List into Flatten Tree.cpp b/Binary Search Tree/BST To Sorten Linked List into Flatten Tree.cpp
new file mode 100644
index 0000000..a7e9b67
--- /dev/null
+++ b/Binary Search Tree/BST To Sorten Linked List into Flatten Tree.cpp	
@@ -0,0 +1,55 @@
+#include<iostream>
+#include<queue>
+using namespace std;
+class node
+{
+	public:
+		int data;
+		node*left;
+		node*right;
+		node(int d)
+		{
+			data=d;
+			left=NULL;
+			right=NULL;
+		}
+};
+node*  insertinBST(node*root,int data)
+{
+	if(root==NULL)
+	{
+		return new node(data);
+	}
+	if(data<root->data)
+	{
+		root->left=insertinBST(root->left,data);
+	}
+	else
+	{
+		root->right=insertinBST(root->right,data);
+	}
+	return root;
+}
+class linkedlist
+{
+	public:
+		node* head;
+		node* tail;
+};
+linkedlist flatten(node*root)
+{
+	linkedlist l;
+	
+}
+node* build()
+{
+	node*root=NULL;
+	int d;
+	cin>>d;
+	if(d!=-1)
+	{
+		insertinBST(root,d);
+		cin>>d;
+	}
+	return root;
+}
diff --git a/HASHTABLE/HASHTABLE Implementation.cpp b/HASHTABLE/HASHTABLE Implementation.cpp
new file mode 100644
index 0000000..59af842
--- /dev/null
+++ b/HASHTABLE/HASHTABLE Implementation.cpp	
@@ -0,0 +1,102 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+template<typename T>
+class Node
+{
+	public:
+		string key;
+		T value;
+		Node<T>*next;
+		Node(string key,T val)      //constructor
+		{
+			this->key=key;
+			value=val;
+			next=NULL;
+		}	
+		~Node()                 //destructor to delete a node
+		{
+			if(next!=NULL)
+			{
+				delete next;
+			}
+		}	
+};
+template<typename T>
+class Hashtable
+{
+	Node<T>** table;    //pointer to an array of pointers
+	int current_size;
+	int table_size;
+	
+	int hashfn(string key)
+	{
+		int idx=0;
+		int p=1;
+		for(int j=0;j<key.length();j++)
+		{
+			idx=idx+(key[j]*p) %table_size;
+			idx=idx %table_size;
+			p=(p*27) %table_size;     // taken a prime no. for min. collision.
+		}
+		return idx;
+	}
+	public:
+		Hashtable(int ts=7)
+		{
+			table_size=ts;     //initializing the table_size=7, can dynamically increase on demand 
+			table=new Node<T>*[table_size];       // dynamically allocating the table 
+			current_size=0;
+			for(int i=0;i<table_size;i++)
+			{
+				table[i]=NULL;           //initialising the table with NULL
+			}
+		}
+		
+		void insert(string key,T value)
+		{
+			int idx=hashfn(key);                  //recieving the index where that key is stored
+			Node<T>*n=new Node<T> (key,value);    //node of linked list containing key and value
+			//insert at the head of the linked list with id=idx
+			n->next=table[idx];          //assinging the next node of linked list to the index of the table 
+			table[idx]=n;                // storing the node at the starting 
+			current_size++;
+			//rehash....
+		}
+		void print()
+		{
+			for(int i=0;i<table_size;i++)
+			{
+				cout<<"Bucket "<<i<<"->";
+				Node<T>*temp=table[i];
+				while(temp!=NULL)
+				{
+					cout<<temp->key<<"->";
+					temp=temp->next;
+				}
+				cout<<endl;
+			}			
+		}		
+};
+int main()
+{
+	Hashtable<int> price_menu;
+	price_menu.insert("Burger",120);
+	price_menu.insert("Pepsi",20);
+	price_menu.insert("BurgerPizza",150);
+	price_menu.insert("Noodles",25);
+	price_menu.insert("Coke",40);
+	price_menu.print();
+	return 0;
+}
+/*
+o/p:
+
+Bucket 0->
+Bucket 1->
+Bucket 2->Noodles->
+Bucket 3->Burger->
+Bucket 4->Coke->Pepsi->
+Bucket 5->BurgerPizza->
+Bucket 6->
+*/
diff --git a/HASHTABLE/HASHTABLE Implementation.h b/HASHTABLE/HASHTABLE Implementation.h
new file mode 100644
index 0000000..c663a16
--- /dev/null
+++ b/HASHTABLE/HASHTABLE Implementation.h	
@@ -0,0 +1,67 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+template<typename T>
+class Node
+{
+	public:
+		string key;
+		T value;
+		Node<T*>next;
+		Node(string key,T val)      //constructor
+		{
+			this->key=key;
+			value=val;
+			next=NULL;
+		}	
+		~Node()                 //destructor
+		{
+			if(next!=NULL)
+			{
+				delete next;
+			}
+		}	
+};
+template<typename T>
+class Hashtable
+{
+	Node<T>** table;    //pointer to an array of pointers
+	int current_size;
+	int table_size;
+	
+	int hashfn(string key)
+	{
+		int idx=0;
+		int p=1;
+		for(int j=0;j<key.length();j++)
+		{
+			idx=idx+(key[j]*p)%table_size;
+			idx=idx%table_size;
+			p=(p*27)%table_size;
+		}
+		return idx;
+	}
+	public:
+		Hashtable(int ts=7)
+		{
+			table_size=ts;
+			table=new Node<T>*[table_size];
+			current_size=0;
+			for(int i=0;i<table_size;i++)
+			{
+				table[i]=NULL;           //initialising the table with NULL
+			}
+		}
+		
+		void insert(string key,T value)
+		{
+			int idx=hashfn(key);
+			Node<T>*n=new Node<T> (key,value);
+			//insert at the head of the linked list with id=idx
+			n->next=table[idx];
+			table[idx]=n;
+			current_size++;
+			//rehash....
+		}
+		//void print()
+};
diff --git a/HASHTABLE/HASHTABLE print Implementation.cpp b/HASHTABLE/HASHTABLE print Implementation.cpp
new file mode 100644
index 0000000..8d95f5c
--- /dev/null
+++ b/HASHTABLE/HASHTABLE print Implementation.cpp	
@@ -0,0 +1,26 @@
+#include<iostream>
+#include<cstring>
+#include"hastable.h"
+using namespace std;
+int main()
+{
+	Hashtable<int> price_menu;
+	price_menu.insert("Burger",120);
+	price_menu.insert("Pepsi",20);
+	price_menu.insert("BurgerPizza",150);
+	price_menu.insert("Noodles",25);
+	price_menu.insert("Coke",40);
+	price_menu.print();
+	return 0;
+}
+/*
+o/p:
+
+Bucket 0->
+Bucket 1->
+Bucket 2->Noodles->
+Bucket 3->Burger->
+Bucket 4->Coke->Pepsi->
+Bucket 5->BurgerPizza->
+Bucket 6->
+*/
diff --git a/HASHTABLE/empty b/HASHTABLE/empty
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/HASHTABLE/empty
@@ -0,0 +1 @@
+
diff --git a/HASHTABLE/hastable.h b/HASHTABLE/hastable.h
new file mode 100644
index 0000000..8649b18
--- /dev/null
+++ b/HASHTABLE/hastable.h
@@ -0,0 +1,80 @@
+#include<iostream>
+#include<cstring>
+using namespace std;
+template<typename T>
+class Node
+{
+	public:
+		string key;
+		T value;
+		Node<T>*next;
+		Node(string key,T val)      //constructor
+		{
+			this->key=key;
+			value=val;
+			next=NULL;
+		}	
+		~Node()                 //destructor
+		{
+			if(next!=NULL)
+			{
+				delete next;
+			}
+		}	
+};
+template<typename T>
+class Hashtable
+{
+	Node<T>** table;    //pointer to an array of pointers
+	int current_size;
+	int table_size;
+	
+	int hashfn(string key)
+	{
+		int idx=0;
+		int p=1;
+		for(int j=0;j<key.length();j++)
+		{
+			idx=idx+(key[j]*p)%table_size;
+			idx=idx%table_size;
+			p=(p*27)%table_size;
+		}
+		return idx;
+	}
+	public:
+		Hashtable(int ts=7)
+		{
+			table_size=ts;
+			table=new Node<T>*[table_size];
+			current_size=0;
+			for(int i=0;i<table_size;i++)
+			{
+				table[i]=NULL;           //initialising the table with NULL
+			}
+		}
+		
+		void insert(string key,T value)
+		{
+			int idx=hashfn(key);
+			Node<T>*n=new Node<T> (key,value);
+			//insert at the head of the linked list with id=idx
+			n->next=table[idx];
+			table[idx]=n;
+			current_size++;
+			//rehash....
+		}
+		void print()
+		{
+			for(int i=0;i<table_size;i++)
+			{
+				cout<<"Bucket "<<i<<"->";
+				Node<T>*temp=table[i];
+				while(temp!=NULL)
+				{
+					cout<<temp->key<<"->";
+					temp=temp->next;
+				}
+				cout<<endl;
+			}			
+		}
+};
diff --git a/LINKED LIST/DELETE_head_tail_middle.cpp b/LINKED LIST/DELETE_head_tail_middle.cpp
new file mode 100644
index 0000000..b36a204
--- /dev/null
+++ b/LINKED LIST/DELETE_head_tail_middle.cpp	
@@ -0,0 +1,115 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len+=1;
+	}
+	return len;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATmiddle(node*&head,int data,int p)
+{
+	if(head==NULL or p==0)
+	{
+		insertAThead(head,data);
+	}
+	else if(p>length(head))
+	{
+		insertATtail(head,data);
+	}
+	else
+	{
+		int jump=1;
+		node*temp=head;
+		while(jump<=p-1)
+		{
+			temp=temp->next;
+			jump+=1;
+		}
+		node* n=new node(data);
+		n->next=temp->next;
+		temp->next=n;
+	}
+}
+
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<"->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+void deleteattail(node*&head)
+{
+	node*prev=NULL;
+	node*temp=head;
+	while(temp->next!=NULL)
+	{
+		prev=temp;
+		temp=temp->next;
+	}
+	delete temp;
+	prev->next=NULL;
+	return;
+}
+void deleteathead(node*&head)
+{
+	if(head==NULL)
+	{
+		return;
+	}
+	node*temp=head;
+	head=head->next;
+	delete temp;
+	return;
+}
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertATtail(head,6);
+    insertATmiddle(head,2,3);
+    deleteathead(head);
+    deleteattail(head);
+    print(head);
+    return 0;
+}
diff --git a/LINKED LIST/Even-After-Odd.cpp b/LINKED LIST/Even-After-Odd.cpp
new file mode 100644
index 0000000..d4a1900
--- /dev/null
+++ b/LINKED LIST/Even-After-Odd.cpp	
@@ -0,0 +1,65 @@
+#include<iostream>
+using namespace std;
+class  node
+{
+	public:
+		int data;
+		node*next;
+		node(int d)
+		{
+			data =d;
+			next=NULL;
+		}
+};
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+void buildlist(node*&head,int n)
+{
+	int data;
+	while(n--)
+	{
+		cin>>data;
+		insertattail(head,data);
+	}
+}
+node*place(node*&head)
+{
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<"->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+int main()
+{
+	node* head=NULL;
+	int n;
+	cin>>n;
+	buildlist(head,n);
+	place(head);
+	print(head);
+	return 0;
+}
diff --git a/LINKED LIST/Even-After-Odd2.cpp b/LINKED LIST/Even-After-Odd2.cpp
new file mode 100644
index 0000000..ce78d45
--- /dev/null
+++ b/LINKED LIST/Even-After-Odd2.cpp	
@@ -0,0 +1,68 @@
+#include<iostream>
+#include<list>
+using namespace std;
+class node
+{
+    public:
+        int data;
+        node*next;
+    node(int d)
+    {
+        data = d;
+        next = NULL;
+    }
+};
+void insertattail(node*&head , int data)
+{
+    if(head == NULL)
+    {
+        head = new node(data);
+        return;
+    }
+    node *temp = head;
+    while(temp->next!=NULL)
+    {
+        temp = temp ->next;
+    }
+    node *n = new node(data);
+    temp -> next = n ; 
+    return;
+}
+void build(node*&head)
+{
+    int length;
+    cin>>length;
+    int data;
+    for(int i = 0 ; i < length ; i++)
+    {
+        cin>>data; 
+        insertattail(head,data);
+    }
+}
+void dist(node *&head , list <int> l)
+{
+    node*temp = head;
+    while(temp != NULL)
+    {
+        if(temp->data % 2 != 0)
+        {
+            cout<<temp->data<<" ";
+            temp = temp -> next ;
+        }
+        else
+        {
+            l.push_back(temp->data);
+            temp = temp -> next;
+        }
+    }
+    for(int i:l){
+        cout<<i<<" ";
+    }
+}
+int main()
+{
+    list <int> l;
+    node*head = NULL;
+    build(head);
+    dist(head,l);
+}
diff --git a/LINKED LIST/Forward_list_STL.cpp b/LINKED LIST/Forward_list_STL.cpp
new file mode 100644
index 0000000..eef5f97
--- /dev/null
+++ b/LINKED LIST/Forward_list_STL.cpp	
@@ -0,0 +1,26 @@
+#include<iostream>
+#include<list>
+using namespace std;
+int main()
+{
+	list<int> l;
+	list<int> l1{1,2,3,4,5};
+	list<string>l2{"apple","guava","mango","banana"};
+	l2.push_back("pineapple");
+    l2.sort();
+    l2.reverse();
+    cout<<l2.front()<<endl;
+    l2.push_front("kiwi");
+  //  l2.pop_front();
+    cout<<l2.back()<<endl;
+    l2.pop_back();
+    for(auto it=l2.begin();it!=l2.end();it++)
+    {
+        cout<<(*it)<<"->";
+    }
+    cout<<endl;
+	for(string s:l2)
+	{
+		cout<<s<<"->";
+	}
+}
diff --git a/LINKED LIST/Forward_list_STL2.cpp b/LINKED LIST/Forward_list_STL2.cpp
new file mode 100644
index 0000000..0fd7994
--- /dev/null
+++ b/LINKED LIST/Forward_list_STL2.cpp	
@@ -0,0 +1,43 @@
+#include<iostream>
+#include<list>
+using namespace std;
+int main()
+{
+	list<int> l;
+	list<int> l1{1,2,3,4,5};
+	list<string>l2{"apple","guava","mango","banana"};
+	l2.push_back("pineapple");
+    l2.sort();
+    l2.reverse();
+    cout<<l2.front()<<endl;
+    l2.push_front("kiwi");
+  //  l2.pop_front();
+    cout<<l2.back()<<endl;
+    l2.pop_back();
+    l2.push_back("orange");
+    l2.push_back("lemon");
+    //remove a fruit by value
+    string f;
+    cin>>f;
+    l2.remove(f);
+    // or else like
+    l2.remove("mango");
+    //removing 3rd element
+    auto it=l2.begin();
+    it++;
+    it++;
+    l2.erase(it);
+    //insert
+    it=l2.begin();
+    it++;
+    l2.insert(it,"fruit juice");
+    for(auto it=l2.begin();it!=l2.end();it++)
+    {
+        cout<<(*it)<<"->";
+    }
+    cout<<endl;
+	for(string s:l2)
+	{
+		cout<<s<<"->";
+	}
+}
diff --git a/LINKED LIST/INSERTION_head_tail_btw.cpp b/LINKED LIST/INSERTION_head_tail_btw.cpp
new file mode 100644
index 0000000..aebdde0
--- /dev/null
+++ b/LINKED LIST/INSERTION_head_tail_btw.cpp	
@@ -0,0 +1,90 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len+=1;
+	}
+	return len;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATmiddle(node*&head,int data,int p)
+{
+	if(head==NULL or p==0)
+	{
+		insertAThead(head,data);
+	}
+	else if(p>length(head))
+	{
+		insertATtail(head,data);
+	}
+	else
+	{
+		int jump=1;
+		node*temp=head;
+		while(jump<=p-1)
+		{
+			temp=temp->next;
+			jump+=1;
+		}
+		node* n=new node(data);
+		n->next=temp->next;
+		temp->next=n;
+	}
+}
+
+void print(node*head)
+{
+	while(head!=NULL)
+	{
+		cout<<head->data<<"->";
+		head=head->next;
+	}
+	cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertATtail(head,6);
+    insertATmiddle(head,2,3);
+	print(head);
+    return 0;
+}
diff --git a/LINKED LIST/INSERT_atHead.cpp b/LINKED LIST/INSERT_atHead.cpp
new file mode 100644
index 0000000..690e7e8
--- /dev/null
+++ b/LINKED LIST/INSERT_atHead.cpp	
@@ -0,0 +1,54 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<" ->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertATtail(head,6);
+    print(head);
+    return 0;
+}
diff --git a/LINKED LIST/Kth element from last in.cpp b/LINKED LIST/Kth element from last in.cpp
new file mode 100644
index 0000000..960e4e5
--- /dev/null
+++ b/LINKED LIST/Kth element from last in.cpp	
@@ -0,0 +1,63 @@
+#include<iostream>
+using namespace std;
+class  node
+{
+	public:
+		int data;
+		node*next;
+		node(int d)
+		{
+			data =d;
+			next=NULL;
+		}
+};
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+node*fndlst(node*head,int k)
+{
+	node*fast=head;
+	node*slow=head;
+	while(k--)
+	{
+		fast=fast->next;
+	}
+	while(fast!=NULL)
+	{
+		fast=fast->next;
+		slow=slow->next;
+	}
+	return slow;
+}
+void buildlist(node*&head)
+{
+	int data;
+	cin>>data;
+	while(data!=-1)
+	{
+		insertattail(head,data);
+		cin>>data;
+	}
+}
+int main()
+{
+	node*head=NULL;
+	buildlist(head);
+	int k;
+	cin>>k;
+	node*m=fndlst(head,k);
+	cout<<m->data;
+	return 0;
+}
diff --git a/LINKED LIST/Kth node_from end.cpp b/LINKED LIST/Kth node_from end.cpp
new file mode 100644
index 0000000..65cbe41
--- /dev/null
+++ b/LINKED LIST/Kth node_from end.cpp	
@@ -0,0 +1,83 @@
+#include<iostream>
+using namespace std;
+class  node
+{
+	public:
+		int data;
+		node*next;
+		node(int d)
+		{
+			data =d;
+			next=NULL;
+		}
+};
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+void print(node*head)
+{
+	while(head!=NULL)
+	{
+		cout<<head->data<<"->";
+	    head=head->next;
+	}
+	cout<<endl;
+}
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len+=1;
+	}
+	return len;
+}
+node*fndlst(node*head,int k)
+{
+	node*fast=head;
+	node*slow=head;
+	while(k--)
+	{
+		fast=fast->next;
+	}
+	while(fast!=NULL)
+	{
+		fast=fast->next;
+		slow=slow->next;
+	}
+	return slow;
+}
+void buildlist(node*&head)
+{
+	int data;
+	cin>>data;
+	while(data!=-1)
+	{
+		insertattail(head,data);
+		cin>>data;
+	}
+}
+int main()
+{
+	node*head=NULL;
+	buildlist(head);
+	print(head);
+	int k;
+	cin>>k;
+	node*m=fndlst(head,k);
+	cout<<m->data;
+	return 0;
+}
diff --git a/LINKED LIST/Linked List-K Append.cpp b/LINKED LIST/Linked List-K Append.cpp
new file mode 100644
index 0000000..740726c
--- /dev/null
+++ b/LINKED LIST/Linked List-K Append.cpp	
@@ -0,0 +1,88 @@
+#include<iostream>
+using namespace std;
+class  node
+{
+	public:
+		int data;
+		node*next;
+		node(int d)
+		{
+			data =d;
+			next=NULL;
+		}
+};
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+
+void buildlist(node*&head,int n)
+{
+	int data;
+	while(n--)
+	{
+		cin>>data;
+		insertattail(head,data);
+	}
+}
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len++;
+	}
+	return len;
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<"->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+void append(node*&head,int k)
+{
+	node*temp=head;
+	node*ptr1=head;
+	node*ptr2=head;
+	while((length(head)-k)>0)
+	{
+		head=head->next;
+	}
+	while((length(head)-k-1)>0)
+	{
+		ptr1=ptr1->next;		
+	}
+	ptr1->next=NULL;
+	while(length(head)>0)
+	{
+		ptr2=ptr2->next;
+	}
+	ptr2->next=temp;
+}
+int main()
+{
+	node* head=NULL;
+	int n,k;
+	cin>>n;
+	buildlist(head,n);
+	cin>>k;
+	append(head,k);
+	print(head);
+	return 0;
+}
diff --git a/LINKED LIST/LinkedList_atHead.cpp b/LINKED LIST/LinkedList_atHead.cpp
new file mode 100644
index 0000000..1095e45
--- /dev/null
+++ b/LINKED LIST/LinkedList_atHead.cpp	
@@ -0,0 +1,39 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<" ->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    print(head);
+    print(head);
+    return 0;
+}
diff --git a/LINKED LIST/MIDPOINT_runner.cpp b/LINKED LIST/MIDPOINT_runner.cpp
new file mode 100644
index 0000000..7bd2506
--- /dev/null
+++ b/LINKED LIST/MIDPOINT_runner.cpp	
@@ -0,0 +1,71 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+		int data;
+		node*next;
+		node(int d)
+		{
+			data=d;
+			next=NULL;
+		}
+};
+void insertathead(node*&head,int data)
+{
+	node*n=new node(data);
+	n->next=head;
+	head=n;
+}
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+void print(node*head)
+{
+	while(head!=NULL)
+	{
+		cout<<head->data<<"->";
+		head=head->next;
+	}
+	cout<<endl;
+}
+node* mid(node*head)
+{
+	if(head==NULL or head->next==NULL)
+	{
+		return head;
+	}
+	node*slow=head;
+	node*fast=head->next;
+	while(fast!=NULL and fast->next!=NULL)
+	{
+		fast=fast->next->next;
+		slow=slow->next;
+	}
+	return slow;
+}
+int main()
+{
+	node*head=NULL;
+	insertathead(head,1);
+	insertathead(head,2);
+	insertathead(head,3);
+	insertathead(head,4);
+	insertattail(head,5);
+	node*m=mid(head);
+	print(head);
+	cout<<m->data<<endl;
+	return 0;
+}
diff --git a/LINKED LIST/MIDPOINT_runner2.cpp b/LINKED LIST/MIDPOINT_runner2.cpp
new file mode 100644
index 0000000..7a3721c
--- /dev/null
+++ b/LINKED LIST/MIDPOINT_runner2.cpp	
@@ -0,0 +1,77 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+		int data;
+		node*next;
+		node(int d)
+		{
+			data=d;
+			next=NULL;
+		}
+};
+void insertathead(node*&head,int data)
+{
+	node*n=new node(data);
+	n->next=head;
+	head=n;
+}
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+void print(node*head)
+{
+	while(head!=NULL)
+	{
+		cout<<head->data<<"->";
+		head=head->next;
+	}
+	cout<<endl;
+}
+node* mid(node*head)
+{
+	if(head==NULL or head->next==NULL)
+	{
+		return head;
+	}
+	node*slow=head;
+	node*fast=head->next;
+	while(fast!=NULL and fast->next!=NULL)
+	{
+		fast=fast->next->next;
+		slow=slow->next;
+	}
+	return slow;
+}
+void buildlist(node*&head)
+{
+	int data;
+	cin>>data;
+	while(data!=-1)
+	{
+		insertattail(head,data);
+		cin>>data;
+	}
+}
+int main()
+{
+	node*head=NULL;
+	buildlist(head);
+	print(head);
+	node*m=mid(head);
+	cout<<m->data<<endl;
+	return 0;
+}
diff --git a/LINKED LIST/Merge Sorted Linked Lists.cpp b/LINKED LIST/Merge Sorted Linked Lists.cpp
new file mode 100644
index 0000000..7501aa6
--- /dev/null
+++ b/LINKED LIST/Merge Sorted Linked Lists.cpp	
@@ -0,0 +1,94 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+	int data;
+	node*next;
+	node(int d)
+	{
+		data=d;
+		next=NULL;
+	}
+};
+node*merge(node*a,node*b)
+{
+	if(a==NULL)
+	{
+		return b;
+	}
+	else if(b==NULL)
+	{
+		return a;
+	}
+	node*c;
+	if(a->data<b->data)
+	{
+		c=a;
+		c->next=merge(a->next,b);
+	}
+	else
+	{
+		c=b;
+		c->next=merge(a,b->next);
+	}
+	return c;
+}
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void buildlist(node*&head)
+{
+	int data;
+	cin>>data;
+	while(data!=-1)
+	{
+		insertattail(head,data);
+		cin>>data;
+	}
+}
+void print(node*head)
+{
+	node*temp=head;
+	while(temp!=NULL)
+	{
+		cout<<temp->data<<"->";
+		temp=temp->next;
+	}
+	cout<<endl;
+}
+node*mergesort()
+istream& operator>> (istream &is, node*&head)
+{
+	buildlist(head);
+	return is;
+}
+ostream& operator<< (ostream &os, node*&head)
+{
+	print(head);
+	return os;
+}
+
+int main()
+{
+	node*head=NULL;
+	node*head2=NULL;
+	cin>>head>>head2;
+	cout<<head<<endl<<head2<<endl;;
+	head=merge(head,head2);
+	cout<<head;
+	
+    return 0;
+}
diff --git a/LINKED LIST/Merge Sorted Linked ListsQUES.cpp b/LINKED LIST/Merge Sorted Linked ListsQUES.cpp
new file mode 100644
index 0000000..17f2218
--- /dev/null
+++ b/LINKED LIST/Merge Sorted Linked ListsQUES.cpp	
@@ -0,0 +1,90 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+	int data;
+	node*next;
+	node(int d)
+	{
+		data=d;
+		next=NULL;
+	}
+};
+node*merge(node*a,node*b)
+{
+	if(a==NULL)
+	{
+		return b;
+	}
+	else if(b==NULL)
+	{
+		return a;
+	}
+	node*c;
+	if(a->data<b->data)
+	{
+		c=a;
+		c->next=merge(a->next,b);
+	}
+	else
+	{
+		c=b;
+		c->next=merge(a,b->next);
+	}
+	return c;
+}
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void buildlist(node*&head,int n)
+{
+	int data;
+	while(n--)
+	{
+		cin>>data;
+		insertattail(head,data);
+	}
+}
+void print(node*head)
+{
+	node*temp=head;
+	while(temp!=NULL)
+	{
+		cout<<temp->data<<"->";
+		temp=temp->next;
+	}
+	cout<<endl;
+}
+int main()
+{
+	node*head=NULL;
+	node*head2=NULL;
+	int t,m,n;
+	cin>>t;
+    for(int i=0;i<t;i++)
+	{
+		cin>>n;
+	buildlist(head,n);
+		cin>>m;
+	buildlist(head2,m);
+	head=merge(head,head2);
+    }
+    for(int i=0;i<t;i++)
+    {
+    	print(head);
+	}
+    return 0;
+}
diff --git a/LINKED LIST/ODD_EVEN_LinkedList.cpp b/LINKED LIST/ODD_EVEN_LinkedList.cpp
new file mode 100644
index 0000000..7839667
--- /dev/null
+++ b/LINKED LIST/ODD_EVEN_LinkedList.cpp	
@@ -0,0 +1,44 @@
+#include<iostream>
+#include<list>
+using namespace std;
+int main()
+{
+	list<int>l;
+	list<int> eve;
+	list<int> odd;
+	int n,d;
+	cin>>n;
+	for(int i=0;i<n;i++)
+	{
+		cin>>d;
+		l.push_back(d);
+	}
+	for(int i=0;i<n;i++)
+	{
+		if(l.front()%2==0)
+		{
+			eve.push_back(l.front());
+		}
+		else
+		{
+			odd.push_back(l.front());
+		}
+		l.pop_front();
+	}
+    for(auto y:odd)
+	{
+		cout<<y<<"->";
+	}
+	for(auto x:eve)
+	{
+		cout<<x<<"->";
+	}
+	
+}
+/*
+i/p:
+10
+1 2 3 4 5 6 7 8 9 10
+o/p:
+1->3->5->7->9->2->4->6->8->10->
+*/
diff --git a/LINKED LIST/OVERLOADING_operator.cpp b/LINKED LIST/OVERLOADING_operator.cpp
new file mode 100644
index 0000000..d5db932
--- /dev/null
+++ b/LINKED LIST/OVERLOADING_operator.cpp	
@@ -0,0 +1,74 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+		int data;
+		node*next;
+		node(int data)
+		{
+			this->data=data;
+			next=NULL;
+		}
+};
+void insertattail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void buildlist(node*&head)
+{
+	int data;
+	cin>>data;
+	while(data!=-1)
+	{
+		insertattail(head,data);
+		cin>>data;
+	}
+}
+void print(node*head)
+{
+	node*temp=head;
+	while(temp!=NULL)
+	{
+		cout<<temp->data<<"->";
+		temp=temp->next;
+	}
+	cout<<endl;
+}
+istream& operator>>(istream &is,node*&head)
+{
+	buildlist(head);
+	return is; 
+}
+ostream& operator<<(ostream &os,node*&head)
+{
+	print(head);
+	return os;
+}
+int main()
+{
+	node*head=NULL;
+	node*head2=NULL;
+	cin>>head>>head2;
+	cout<<head<<endl<<head2;
+	return 0;
+}
+
+/* input as:
+            1 2 3 -1
+            4 5 6 -1
+    output:
+            1->2->3->
+
+            4->5->6->  */
diff --git a/LINKED LIST/REVERSE.cpp b/LINKED LIST/REVERSE.cpp
new file mode 100644
index 0000000..2755cfe
--- /dev/null
+++ b/LINKED LIST/REVERSE.cpp	
@@ -0,0 +1,54 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+		int data;
+		node*next;
+		node(int data)
+		{
+			this->data=data;
+			next=NULL;
+		}
+};
+void reverse(node*&head)
+{
+	node*c=head;
+	node*p=NULL;
+	node*n=NULL;
+	while(c!=NULL)
+	{
+		n=c->next;
+		c->next=p;
+		p=c;
+		c=n;
+	}
+	head=p;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<" ->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+int main()
+{
+	node*head=NULL;
+	insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertAThead(head,2);
+    print(head);
+    reverse(head);
+    print(head);
+	return 0;
+}
diff --git a/LINKED LIST/REVERSE1.cpp b/LINKED LIST/REVERSE1.cpp
new file mode 100644
index 0000000..7db9c9b
--- /dev/null
+++ b/LINKED LIST/REVERSE1.cpp	
@@ -0,0 +1,107 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len+=1;
+	}
+	return len;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATmiddle(node*&head,int data,int p)
+{
+	if(head==NULL or p==0)
+	{
+		insertAThead(head,data);
+	}
+	else if(p>length(head))
+	{
+		insertATtail(head,data);
+	}
+	else
+	{
+		int jump=1;
+		node*temp=head;
+		while(jump<=p-1)
+		{
+			temp=temp->next;
+			jump+=1;
+		}
+		node* n=new node(data);
+		n->next=temp->next;
+		temp->next=n;
+	}
+}
+
+
+void reverse(node*&head)
+{
+	node*c=head;
+	node*p=NULL;
+	node*n=NULL;
+	while(c!=NULL)
+	{
+		n=c->next;
+		c->next=p;
+		p=c;
+		c=n;
+	}
+	head=p;
+}
+void print(node*head)
+{
+	while(head!=NULL)
+	{
+		cout<<head->data<<"->";
+		head=head->next;
+	}
+	cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertATtail(head,6);
+    insertATmiddle(head,2,3);
+	print(head);
+	reverse(head);
+	print(head);
+    return 0;
+}
diff --git a/LINKED LIST/SEARCHING_recursive_iterative.cpp b/LINKED LIST/SEARCHING_recursive_iterative.cpp
new file mode 100644
index 0000000..3503008
--- /dev/null
+++ b/LINKED LIST/SEARCHING_recursive_iterative.cpp	
@@ -0,0 +1,135 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len+=1;
+	}
+	return len;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATmiddle(node*&head,int data,int p)
+{
+	if(head==NULL or p==0)
+	{
+		insertAThead(head,data);
+	}
+	else if(p>length(head))
+	{
+		insertATtail(head,data);
+	}
+	else
+	{
+		int jump=1;
+		node*temp=head;
+		while(jump<=p-1)
+		{
+			temp=temp->next;
+			jump+=1;
+		}
+		node* n=new node(data);
+		n->next=temp->next;
+		temp->next=n;
+	}
+}
+bool searchiterative(node*head,int key)
+{
+	while(head!=NULL)
+	{
+		if(head->data==key)
+		{
+			return true;
+		}
+		head=head->next;
+	}
+	return false;
+}
+bool searchRecursive(node*head,int key)
+{
+	if(head==NULL)
+	{
+		return false;
+	}
+	if(head->data==key)
+	{
+		return true;
+	}
+	else
+	{
+		return searchRecursive(head->next,key);
+	}
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<" ->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertATtail(head,6);
+    insertATmiddle(head,2,3);
+    print(head);
+    cout<<endl;
+    int key=4;
+    
+    if(searchRecursive(head,key))
+    {
+    	cout<<"present";
+	}    
+	else
+	{
+		cout<<"not present";
+	}
+	if(searchiterative(head,key))
+    {
+    	cout<<"present";
+	}    
+	else
+	{
+		cout<<"not present";
+	}
+    return 0;
+}
diff --git a/LINKED LIST/Sort linked list using insertion sort.cpp b/LINKED LIST/Sort linked list using insertion sort.cpp
new file mode 100644
index 0000000..4d33956
--- /dev/null
+++ b/LINKED LIST/Sort linked list using insertion sort.cpp	
@@ -0,0 +1,20 @@
+#include<iostream>
+#include<list>
+using namespace std;
+int main() {
+	list<int>l;
+    int n;
+	cin>>n;
+	while(n--)
+	{
+		int k;
+		cin>>k;
+		l.push_back(k);
+	}
+	l.sort();
+	for(int i :l)
+	{
+		cout<<i<<" ";
+	}
+	return 0;
+}
diff --git a/LINKED LIST/dedectcycle.cpp b/LINKED LIST/dedectcycle.cpp
new file mode 100644
index 0000000..90b55b1
--- /dev/null
+++ b/LINKED LIST/dedectcycle.cpp	
@@ -0,0 +1,58 @@
+#include<iostream>
+using namespace std; 
+// Create a class node for the circular linked list 
+class node
+{
+	public:
+		int data;
+		node*next;
+	node(int data)
+	{
+		this->data = data; // Refering to data
+		//Here the tail pointer would point to head of the node instead of the NULL 
+	}
+};
+// A function which is used to print the list 
+void printlist(node *head)
+{
+	node *temp = head;
+	while(temp->next != head)
+	{
+		cout<<temp->data<<"->";
+		temp = temp->next;
+	}
+	cout<<temp->data<<endl;
+	cout<<"END";	
+}
+//A function used to push the node in the linked list 
+void push(node *&head , int data)
+{
+	node *ptr1 = new node(data);
+	node *temp = head; 
+	ptr1->next = head; 
+	if(head != NULL)
+	{
+		while(temp->next!=head)
+		{
+			temp = temp->next;
+		}
+		temp->next = ptr1; 
+		
+	}
+	else
+	{
+		ptr1->next = ptr1; 
+	}
+	head = ptr1;
+}
+int main(int argc, char const *argv[])
+{
+	node *head = NULL;
+	push(head,10);
+	push(head,20);
+	push(head,30);
+	push(head,40);
+	printlist(head);
+	return 0;
+	
+}
diff --git a/LINKED LIST/dedectcycle1.cpp b/LINKED LIST/dedectcycle1.cpp
new file mode 100644
index 0000000..b3f6b44
--- /dev/null
+++ b/LINKED LIST/dedectcycle1.cpp	
@@ -0,0 +1,74 @@
+#include<iostream>
+using namespace std; 
+// Create a class node for the circular linked list 
+class node
+{
+	public:
+		int data;
+		node*next;
+	node(int data)
+	{
+		this->data = data; // Refering to data
+		//Here the tail pointer would point to head of the node instead of the NULL 
+	}
+};
+// A function which is used to print the list 
+void printlist(node *head)
+{
+	node *temp = head;
+	while(temp->next != head)
+	{
+		cout<<temp->data<<"->";
+		temp = temp->next;
+	}
+	cout<<temp->data<<endl;
+//	cout<<"END";	
+}
+//A function used to push the node in the linked list 
+void push(node *&head , int data)
+{
+	node *ptr1 = new node(data);
+	node *temp = head; 
+	ptr1->next = head; 
+	if(head != NULL)
+	{
+		while(temp->next!=head)
+		{
+			temp = temp->next;
+		}
+		temp->next = ptr1; 
+		
+	}
+	else
+	{
+		ptr1->next = ptr1; 
+	}
+	head = ptr1;
+}
+bool dedectcycle(node*head)
+{
+	node*slow=head;
+	node*fast=head;
+	while(fast!=NULL and fast->next!=NULL)
+	{
+		fast=fast->next->next;
+		slow=slow->next;
+		if(fast==slow)
+		{
+			return true;
+		}
+		return false;
+	}
+}
+int main(int argc, char const *argv[])
+{
+	node *head = NULL;
+	push(head,10);
+	push(head,20);
+	push(head,30);
+	push(head,40);
+	printlist(head);
+//	cout<<dedectcycle(head);
+	return 0;
+	
+}
diff --git a/LINKED LIST/empty b/LINKED LIST/empty
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/LINKED LIST/empty	
@@ -0,0 +1 @@
+
diff --git a/LINKED LIST/mycheck.cpp b/LINKED LIST/mycheck.cpp
new file mode 100644
index 0000000..3ca9d16
--- /dev/null
+++ b/LINKED LIST/mycheck.cpp	
@@ -0,0 +1,54 @@
+#include<iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<" ->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+  //  insertAThead(head,5);
+    //insertAThead(head,4);
+//    insertAThead(head,3);
+    insertATtail(head,6);
+    print(head);
+    return 0;
+}
diff --git a/LINKED LIST/searching.cpp b/LINKED LIST/searching.cpp
new file mode 100644
index 0000000..3503008
--- /dev/null
+++ b/LINKED LIST/searching.cpp	
@@ -0,0 +1,135 @@
+#include <iostream>
+using namespace std;
+class node
+{
+public:
+    int data;
+    node* next;
+    node(int d)
+    {
+        data=d;
+        next=NULL;
+    }
+};
+int length(node*head)
+{
+	int len=0;
+	while(head!=NULL)
+	{
+		head=head->next;
+		len+=1;
+	}
+	return len;
+}
+void insertATtail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		node* head=new node(data);
+		return;
+	}	
+	node* tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}
+	tail->next=new node(data);
+	return;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void insertATmiddle(node*&head,int data,int p)
+{
+	if(head==NULL or p==0)
+	{
+		insertAThead(head,data);
+	}
+	else if(p>length(head))
+	{
+		insertATtail(head,data);
+	}
+	else
+	{
+		int jump=1;
+		node*temp=head;
+		while(jump<=p-1)
+		{
+			temp=temp->next;
+			jump+=1;
+		}
+		node* n=new node(data);
+		n->next=temp->next;
+		temp->next=n;
+	}
+}
+bool searchiterative(node*head,int key)
+{
+	while(head!=NULL)
+	{
+		if(head->data==key)
+		{
+			return true;
+		}
+		head=head->next;
+	}
+	return false;
+}
+bool searchRecursive(node*head,int key)
+{
+	if(head==NULL)
+	{
+		return false;
+	}
+	if(head->data==key)
+	{
+		return true;
+	}
+	else
+	{
+		return searchRecursive(head->next,key);
+	}
+}
+void print(node*head)
+{
+    while(head!=NULL)
+    {
+        cout<<head->data<<" ->";
+        head=head->next;
+    }
+    cout<<endl;
+}
+
+int main() 
+{
+    node*head=NULL;
+    insertAThead(head,5);
+    insertAThead(head,4);
+    insertAThead(head,3);
+    insertATtail(head,6);
+    insertATmiddle(head,2,3);
+    print(head);
+    cout<<endl;
+    int key=4;
+    
+    if(searchRecursive(head,key))
+    {
+    	cout<<"present";
+	}    
+	else
+	{
+		cout<<"not present";
+	}
+	if(searchiterative(head,key))
+    {
+    	cout<<"present";
+	}    
+	else
+	{
+		cout<<"not present";
+	}
+    return 0;
+}
diff --git a/LINKED LIST/user_input.cpp b/LINKED LIST/user_input.cpp
new file mode 100644
index 0000000..e5eafdd
--- /dev/null
+++ b/LINKED LIST/user_input.cpp	
@@ -0,0 +1,60 @@
+#include<iostream>
+using namespace std;
+class node
+{
+	public:
+	node*next;
+	int data;
+	node(int d)
+	{
+	    next=NULL;
+		data=d;
+	}
+};
+void insertatTail(node*&head,int data)
+{
+	if(head==NULL)
+	{
+		head=new node(data);
+		return;
+	}
+	node*tail=head;
+	while(tail->next!=NULL)
+	{
+		tail=tail->next;
+	}	
+	tail->next=new node(data);
+	return;
+}
+void insertAThead(node*&head,int data)
+{
+    node* n= new node(data);
+    n->next=head;
+    head=n;
+}
+void print(node*head)
+{
+	while(head!=NULL)
+	{
+		cout<<head->data<<"->";
+		head=head->next;
+	}
+	cout<<endl;
+}
+void buildlist(node*&head)
+{
+	int data;
+	cin>>data;
+	while(data!=-1)
+	{
+		insertatTail(head,data);
+		cin>>data;
+	}
+}
+int main()
+{
+	node*head=NULL;
+	buildlist(head);
+	print(head);
+	return 0;
+}
diff --git a/QUEUES First non repeating character Implementation b/QUEUES First non repeating character Implementation
new file mode 100644
index 0000000..2f5f21f
--- /dev/null
+++ b/QUEUES First non repeating character Implementation	
@@ -0,0 +1,50 @@
+#include<iostream>
+#include<queue>
+using namespace std;
+int main()
+{
+	queue<char> q;
+	int freq[27]={0};   //frequency table initialised woth zeros
+	
+	//running a stream until a '.'
+	char ch;
+	cin>>ch;
+	while(ch!='.')
+	{
+	q.push(ch);         //push in the queue
+	freq[ch-'a']++;     //'a'-'a'=0 _______ 'b'-'a'=1....  and at each frequency if the characters are repeating then incremented
+	
+	while(!q.empty())
+	{
+		int idx=q.front()-'a';    
+		if(freq[idx]>1)      //if characters are repeating
+		{
+			q.pop();        //delete the previous element
+		}
+		else
+		{
+			cout<<q.front()<<endl;     //else print 
+			break;
+		}
+	}
+	//q is empty
+	if(q.empty())           //after poping if no char available then print -1
+	{
+		cout<<"-1"<<endl;
+	}
+	cin>>ch;
+    }
+	return 0;
+}
+/*  i/p:
+        aabccbc.
+       
+  o/p:
+    a
+    -1
+    b
+    b
+    b
+    -1
+    -1
+*/
diff --git a/README.md b/README.md
index 7604f2d..51960db 100644
--- a/README.md
+++ b/README.md
@@ -93,47 +93,26 @@ Searching , is a process of Searching elements in the Linked List. Search could
  3. In the implementation of the advanced algorithm such as Fibonacci Heap 
  
 <h2> List STL Functions </h2>
-
 List is included in the given C++ Program. The function is there to add all its utility and is managed 
-
 <h3> Push_Back() </h3>
-
 This function is used to add the elements at the end of the list 
-
 <h3> Sort() </h3>
-
 This function is used to sort the given list 
-
 <h3> push_front() </h3>
-
 This function is used to add the element at the front of the list 
-
 <h3> pop_back() </h3>
-
 As, the name goes; This function removes the last element from the list 
-
 <h3> pop_front() </h3>
-
 This function removes the first element from the list 
-
 <h3> insert(position,element) </h3>
-
 This function is used to insert the element in the linked list 
-
 <h3> erase(position) </h3>
-
 This function is used to remove the element in the given list 
-
 <h3> remove(element) </h3>
-
 This function removes the given element from the list 
-
 <h3> front() </h3>
-
 This function is used to print the first element in the list 
-
-<h1> Stack </h1>
-
+<h1> STACK </h1>
 Stack is a data structure, which represents the collection of the objects. A item could be added and stored in a stack using push operation. A object can be retrieved using pop operation, to remove an item from the stack. A item could be inserted at the top of the stack. A item could be either removed either from top or bottom of the stack. Their are two types of stack:
 
 1. LIFO(Last In First Out)
@@ -142,9 +121,35 @@ Stack is a data structure, which represents the collection of the objects. A ite
 FIFO stack is basically a type of Queue. 
 
 Stacks have several applications in the Computer Programming. LIFO is used to retrieve, recently used objects from cache. FIFO stacks is used to ensure the data is retrieved in the order it was entered. Stacks are basically created at the background, while application was running in front. If stack, runs out of memory such situation is termed as <b> Stack Overflow </b>.
-
 <h2> Genralizaition of Stack </h2>
 
 A stack could be generalized using templated class <b> template <Typename T> </b> . You can generalize the given code in a following way as told in file <b>generalization of stack </b>
-	
-<h1> Queue </h1>
+ 
+ <h2>STL Stack Functions </h2>
+<b>stack</b> header file is used in order to implement STL functions. The function is there to add all its utility and is managed 
+<h3> push(data) </h3>
+This function is used to add the elements at the end of the list 
+<h3> top() </h3>
+This function is used to check the top most element. 
+<h3> pop() </h3>
+This function is used to delete the element at the front of the list.
+
+
+ <h1> QUEUES </h1>
+ Queue is a data structure designed to operate in FIFO (First in First out) context. In queue elements are inserted from rear end and get removed from front end operations called <b>'enqueued'</b> and <b>'dequed'</b> respectively. Queue class is container adapter. Container is an objects that hold data of same type. Queue can be created from different sequence containers.
+ <h4> There are two ways to implement Queues</h4>
+ 
+ 
+   1. Circular Array based 
+   2. Linked List based 
+   
+   <b>Out of the two Circular Array based implementation is quite lengthier than the Linked List based implementation.</b>
+   
+   <h2>STL Queue class function</h2>
+<b>queue</b> header file is used in order to implement STL functions. The function is there to add all its utility and is managed 
+<h3> push(data) </h3>
+This function is used to add the elements at the end of the list 
+<h3> front() </h3>
+This function is used to check the front element. 
+<h3> pop() </h3>
+This function is used to delete the element at the front of the list.
diff --git a/Stack and Queue/Balanced_Brackets.cpp b/Stack and Queue/Balanced_Brackets.cpp
new file mode 100644
index 0000000..7fb68ce
--- /dev/null
+++ b/Stack and Queue/Balanced_Brackets.cpp	
@@ -0,0 +1,63 @@
+#include<iostream>
+#include<stack>
+#include<cstring>
+using namespace std;
+bool checkexpr(string str)
+{
+	stack<char>s;
+	for(int i=0;i<str.size();i++)
+	{
+	
+		char cur=str[i];
+		if(cur=='(' or cur=='[' or cur=='{')
+		{
+			s.push(cur);
+		}
+		else if(cur==')')
+		{
+			if(s.empty() or s.top()!='(')
+			{
+				return false;
+			}
+			s.pop();
+		}
+		else if(cur==']')
+		{
+			if(s.empty() or s.top()!='[')
+			{
+				return false;
+			}
+			s.pop();
+		}
+		else if(cur=='}')
+		{
+			if(s.empty() or s.top()!='{')
+			{
+				return false;
+			}
+			s.pop();
+		}
+	}
+	if(s.empty()){
+		return true;
+	}
+	else{
+		return false;
+	}
+}
+int main() 
+{
+	string expr;
+	getline(cin, expr); 
+    int isvalid=checkexpr(expr);    
+
+	if(isvalid==1)
+	{
+		cout<<"true";
+	}
+	else if(isvalid==0)
+	{
+	cout<<"false";
+    }
+	return 0;
+}
diff --git a/Stack and Queue/Duplicate_Brackets.cpp b/Stack and Queue/Duplicate_Brackets.cpp
new file mode 100644
index 0000000..ccf99c3
--- /dev/null
+++ b/Stack and Queue/Duplicate_Brackets.cpp	
@@ -0,0 +1,48 @@
+#include<iostream>
+#include<stack>
+#include<string>
+using namespace std;
+
+bool redundant(string str)
+{
+    stack <char> s; 
+   
+    int n = str.length() ; 
+    for(int i = 0 ; i < n;i++)
+    {
+        if(str[i] == ')' && !s.empty())
+        {
+            if(s.top() == '('){
+                return true;
+            }
+            else{
+                while(s.top() != '('){
+                    s.pop();
+                }
+                s.pop();
+            }
+
+        }
+        else
+        {
+            s.push(str[i]) ;
+        }
+    }
+    return false ;     
+}
+
+ 
+int main(){
+
+        string str ; 
+        getline(cin, str); 
+        if(redundant(str))
+        {
+            cout<<"true"<<endl ; 
+        }
+        else
+        {
+            cout<<"false"<<endl ; 
+        }
+
+    }
diff --git a/Stack and Queue/Infix_Evaluation.cpp b/Stack and Queue/Infix_Evaluation.cpp
new file mode 100644
index 0000000..eb2a524
--- /dev/null
+++ b/Stack and Queue/Infix_Evaluation.cpp	
@@ -0,0 +1,126 @@
+#include<iostream>
+#include<string>
+#include<stack>
+using namespace std;
+
+int precidence(char oper){
+	if(oper == '+'){
+		return 1;
+	}
+	else if(oper == '-'){
+		return 1;
+	}
+	else if(oper == '*'){
+		return 2;
+	}
+	else if(oper == '/'){
+		return 2;
+	}
+	return 0;
+}
+
+int operation(int v1 , int v2, char oper){
+	if(oper == '+'){
+		return v1 + v2;
+	}
+	else if(oper == '-'){
+		return v1 - v2;
+	}
+	else if(oper == '*'){
+		return v1 * v2;
+	}
+	else if(oper == '/'){
+		return v1 / v2;
+	}
+	return 0;
+}
+
+int main()
+{
+	string str;
+	getline(cin , str);
+	stack<int> o1;
+	stack<char> o2;
+
+	for(int i = 0 ; i < str.length() ; i++)
+	{
+	    char ch = str.at(i);
+        if(ch == ' ')
+        {
+        	continue;
+        }
+        else
+        {
+            if(ch == '(')
+            {
+            	o2.push(ch);
+            }
+            else if(ch == ')')
+            {
+            	while(o2.top() != '('){
+            	char op = o2.top();
+            	o2.pop();
+            	int v2 = o1.top();
+            	o1.pop();
+            	int v1 = o1.top();
+            	o1.pop();
+            	int ans = operation(v1 ,v2 , op);
+            	o1.push(ans);
+            }
+            o2.pop();
+            }
+            else if(ch == '+' || ch == '-' || ch == '*' || ch == '/')
+            {
+              	int pc = precidence(str[i]);
+              	while(!o2.empty() && o2.top() != '(' && precidence(o2.top()) >= pc)
+              	{
+              	    char op = o2.top();
+            		o2.pop();
+            		int v2 = o1.top();
+            		o1.pop();
+            		int v1 = o1.top();
+            		o1.pop();
+            		int ans = operation(v1 ,v2 , op);
+            		o1.push(ans);
+              	}
+              	o2.push(ch);
+            }
+            else
+            {
+            	o1.push(int(str[i])- 48);
+            }
+        }
+    }
+        	while(!o2.empty()){
+			char op = o2.top();
+			o2.pop();
+			int v2 = o1.top();
+			o1.pop();
+			int v1 = o1.top();
+			o1.pop();
+			int ans = operation(v1 ,v2 , op);
+			o1.push(ans);
+		}
+		cout<<o1.top();
+
+	return 0;
+}
+/*
+Infix Evaluation
+
+Question
+1. You are given an infix expression.
+2. You are required to evaluate and print it's value.
+
+Constraints
+1. Expression is balanced
+2. The only operators used are +, -, *, /
+3. Opening and closing brackets - () - are used to impact precedence of operations
+4. + and - have equal precedence which is less than * and /. * and / also have equal precedence.
+5. In two operators of equal precedence give preference to the one on left.
+6. All operands are single digit numbers.
+Sample Input
+2 + 6 * 4 / 8 - 3
+Sample Output
+2
+*/
diff --git a/Stack and Queue/Next-Greater_Element_To_The_Right.cpp b/Stack and Queue/Next-Greater_Element_To_The_Right.cpp
new file mode 100644
index 0000000..86d272a
--- /dev/null
+++ b/Stack and Queue/Next-Greater_Element_To_The_Right.cpp	
@@ -0,0 +1,52 @@
+#include<iostream>
+#include<stack>
+using namespace std;
+int main()
+{
+    stack<int >s1,s2;
+    int n;
+    cin>>n;
+    int a[n];
+    for(int i=0;i<n;i++)
+    {
+        cin>>a[i];
+    }
+    s1.push(a[n-1]);
+    s2.push(-1);
+    for(int i=n-2;i>=0;i--)
+    {
+        while(!s1.empty() and a[i]>s1.top())
+        {
+            s1.pop();
+        }
+        if(s1.empty())
+        {
+            s2.push(-1);
+        }
+        else
+        {
+            s2.push(s1.top());
+        }
+        s1.push(a[i]);
+    }
+    while(!s2.empty())
+    {
+        cout<<s2.top()<<endl;
+        s2.pop();
+    }
+}
+/*
+Sample Input
+5
+5
+3
+8
+-2
+7
+Sample Output
+8
+8
+-1
+7
+-1
+*/
diff --git a/Stack and Queue/Smallest_Number_Following_Pattern.cpp b/Stack and Queue/Smallest_Number_Following_Pattern.cpp
new file mode 100644
index 0000000..929cdcf
--- /dev/null
+++ b/Stack and Queue/Smallest_Number_Following_Pattern.cpp	
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<stack>
+#include<cstring>
+using namespace std;
+int main()
+{
+    string str;
+    cin>>str;
+    stack<int> s;
+    int n=1;
+    for(int i=0;i<str.length();i++)
+    {
+        char ch=str[i];
+        if(ch=='d')
+        {
+            s.push(n);
+            n++;
+        }
+        else
+        {
+            s.push(n);
+            n++;
+            while(!s.empty())
+            {
+                cout<<s.top();
+                s.pop();
+            }
+        }
+    }
+    s.push(n);
+    while(!s.empty())
+    {
+        cout<<s.top();
+        s.pop();
+    }
+}
+/*
+Smallest Number Following Pattern
+
+Question
+1. You are given a pattern of upto 8 length containing characters 'i' and 'd'.
+2. 'd' stands for decreasing and 'i' stands for increasing
+3. You have to print the smallest number, using the digits 1 to 9 only without repetition, such that 
+the digit decreases following a d and increases follwing an i.
+
+e.g.
+d -> 21
+i -> 12
+ddd -> 4321
+iii -> 1234
+dddiddd -> 43218765
+iiddd -> 126543
+
+i/p
+dddiidid
+o/p
+432157698
+*/
diff --git a/Stack and Queue/Stock_Span.cpp b/Stack and Queue/Stock_Span.cpp
new file mode 100644
index 0000000..f5819aa
--- /dev/null
+++ b/Stack and Queue/Stock_Span.cpp	
@@ -0,0 +1,58 @@
+#include<iostream>
+#include<stack>
+using namespace std;
+int main()
+{
+    long int n;
+    cin>>n;
+    long int a[n],b[n];
+    for(long int i=0;i<n;i++)
+    {
+        cin>>a[i];
+    }
+    stack<long int> s;
+    b[0]=1;
+    s.push(0);
+    for(long int i=1;i<n;i++)
+    {
+        while(!s.empty() and a[i]>a[s.top()])
+        {
+            s.pop();
+        }
+        if(s.empty())
+        {
+            b[i]=i+1;
+        }
+        else
+        {
+            b[i]=i-s.top();
+        }
+        s.push(i);
+    }
+    for(long int i=0;i<n;i++)
+    {
+        cout<<b[i]<<endl;
+    }
+}
+/*
+9
+3
+2
+9
+5
+4
+7
+3
+1
+5
+o/p
+1
+1
+3
+1
+1
+3
+1
+1
+3
+*/