restructered Tree folder and add AVL tree Cpp

Author: tpriyanshu90

Tree/AVL/AVL.cpp

@@ -0,0 +1,109 @@
+/*AVL TREE INSERTION*/ 
+#include <bits/stdc++.h>
+using namespace std;
+
+struct Node{
+	int data;
+	int height;
+	Node* left;
+	Node* right;
+};
+
+int height(Node* root){
+	if(root==NULL)
+		return 0;
+	return max(height(root->left),height(root->right))+1;
+}
+
+void preOrder(Node * root){
+	if(root==NULL)
+		return;
+	cout<<root->data<<" ";
+	preOrder(root->left);
+	preOrder(root->right);
+	return;
+}
+
+Node* createNewNode(int val){
+	Node* newNode = new Node();
+	newNode->data = val;
+	newNode->left = NULL;
+	newNode->right = NULL;
+	return newNode;
+}
+
+Node * rotateRight(Node * root){
+	Node * newroot = root->left;
+	root->left = newroot->right;
+	newroot->right = root;
+	root->height = height(root);
+	newroot->height = height(newroot);
+	return newroot;
+}
+
+Node * rotateLeft(Node * root){
+	Node* newroot = root->right;
+	root->right = newroot->left;
+	newroot->left = root;
+	root->height = height(root);
+	newroot->height = height(newroot);
+	return newroot;
+}
+
+Node* insertAVL(Node* root, int val){
+	if(root==NULL){
+		root = createNewNode(val);
+	}
+	else if(val<root->data){
+		root->left = insertAVL(root->left, val);
+	}
+	else if(val>root->data){
+		root->right = insertAVL(root->right, val);
+	}
+	int balance = height(root->left) - height(root->right);
+	if(balance>1){ //left height is greater
+		if(height(root->left->left) >= height(root->left->right)){
+			//LL imbalance
+			root = rotateRight(root);
+		}
+		else{
+			//LR imabalace
+			root->left = rotateLeft(root->left);
+			root = rotateRight(root);
+		}
+	}
+	if(balance<-1){
+		if(height(root->right->right) >= height(root->right->left)){
+			//RR imbalance
+			root = rotateLeft(root);
+		}
+		else{
+			//RL imabalace
+			root->right = rotateRight(root->right);
+			root = rotateLeft(root);
+		}
+	}
+	root->height = height(root);
+	return root;
+}
+
+Node* createAVL(int arr[], int n, Node* root){
+	for(int i=0;i<n;i++){
+		root = insertAVL(root, arr[i]);
+	}
+	return root;
+}
+
+int main()
+{
+    int arr[] = {40,20,10,25,30,22,50};
+    int n = sizeof(arr)/sizeof(arr[0]);
+    Node* root = NULL;
+    root = createAVL(arr,n,root);
+    preOrder(root);
+    cout<<endl;
+    insertAVL(root,60);
+    preOrder(root);
+    cout<<endl;
+    return 0;
+}

Tree/Tree Traversal/BFS/C++/BFS.cpp

@@ -0,0 +1,38 @@
+#include<iostream>
+using namespace std;
+int cost[10][10],i,j,k,n,qu[10],front,rare,v,visit[10],visited[10];
+int main()
+{
+    int m;
+    cout <<"Enter no of nodes(max 9):";
+    cin >> n;
+    cout <<"Enter no of edges:";
+    cin >> m;
+    cout <<"\nEnter edges starting from source node: \n";
+    for(k=1; k<=m; k++)
+    {
+        cin >>i>>j;
+        cost[i][j]=1;
+    }
+    cout <<"Re-enter source node to traverse from:";
+    cin >>v;
+    cout <<"Visitied nodes:";
+    cout <<v<<" ";
+    visited[v]=1;
+    k=1;
+    while(k<n)
+    {
+        for(j=1; j<=n; j++)
+            if(cost[v][j]!=0 && visited[j]!=1 && visit[j]!=1)
+            {
+                visit[j]=1;
+                qu[rare++]=j;
+            }
+        v=qu[front++];
+        cout<<v <<" ";
+        k++;
+        visit[v]=0;
+        visited[v]=1;
+    }
+    return 0;
+}

Tree/Tree Traversal/BFS/Python/bfs.py

@@ -0,0 +1,64 @@
+""" 
+ Ref: https://www.geeksforgeeks.org/level-order-tree-traversal/
+ 
+"""
+
+# Recursive Python program for level order traversal of Binary Tree 
+
+# A node structure 
+class Node: 
+
+	# A utility function to create a new node 
+	def __init__(self, key): 
+		self.data = key 
+		self.left = None
+		self.right = None
+
+
+# Function to print level order traversal of tree 
+def printLevelOrder(root): 
+	h = height(root) 
+	for i in range(1, h+1): 
+		printGivenLevel(root, i) 
+
+
+# Print nodes at a given level 
+def printGivenLevel(root , level): 
+	if root is None: 
+		return
+	if level == 1: 
+		print "%d" %(root.data), 
+	elif level > 1 : 
+		printGivenLevel(root.left , level-1) 
+		printGivenLevel(root.right , level-1) 
+
+
+""" Compute the height of a tree--the number of nodes 
+	along the longest path from the root node down to 
+	the farthest leaf node 
+"""
+def height(node): 
+	if node is None: 
+		return 0
+	else : 
+		# Compute the height of each subtree 
+		lheight = height(node.left) 
+		rheight = height(node.right) 
+
+		#Use the larger one 
+		if lheight > rheight : 
+			return lheight+1
+		else: 
+			return rheight+1
+
+# Driver program to test above function 
+root = Node(1) 
+root.left = Node(2) 
+root.right = Node(3) 
+root.left.left = Node(4) 
+root.left.right = Node(5) 
+
+print "Level order traversal of binary tree is -"
+printLevelOrder(root) 
+
+#This code is contributed by Nikhil Kumar Singh(nickzuck_007) 

Tree/Tree Traversal/C++/treetaversal.cpp

@@ -0,0 +1,86 @@
+// C++ program for different tree traversals 
+#include <iostream> 
+using namespace std; 
+  
+/* A binary tree node has data, pointer to left child 
+and a pointer to right child */
+struct Node 
+{ 
+    int data; 
+    struct Node* left, *right; 
+    Node(int data) 
+    { 
+        this->data = data; 
+        left = right = NULL; 
+    } 
+}; 
+  
+/* Given a binary tree, print its nodes according to the 
+"bottom-up" postorder traversal. */
+void printPostorder(struct Node* node) 
+{ 
+    if (node == NULL) 
+        return; 
+  
+    // first recur on left subtree 
+    printPostorder(node->left); 
+  
+    // then recur on right subtree 
+    printPostorder(node->right); 
+  
+    // now deal with the node 
+    cout << node->data << " "; 
+} 
+  
+/* Given a binary tree, print its nodes in inorder*/
+void printInorder(struct Node* node) 
+{ 
+    if (node == NULL) 
+        return; 
+  
+    /* first recur on left child */
+    printInorder(node->left); 
+  
+    /* then print the data of node */
+    cout << node->data << " "; 
+  
+    /* now recur on right child */
+    printInorder(node->right); 
+} 
+  
+/* Given a binary tree, print its nodes in preorder*/
+void printPreorder(struct Node* node) 
+{ 
+    if (node == NULL) 
+        return; 
+  
+    /* first print data of node */
+    cout << node->data << " "; 
+  
+    /* then recur on left sutree */
+    printPreorder(node->left);  
+  
+    /* now recur on right subtree */
+    printPreorder(node->right); 
+}  
+  
+/* Driver program to test above functions*/
+int main() 
+{ 
+    struct Node *root = new Node(1); 
+    root->left             = new Node(2); 
+    root->right         = new Node(3); 
+    root->left->left     = new Node(4); 
+    root->left->right = new Node(5);  
+  
+    cout << "\nPreorder traversal of binary tree is \n"; 
+    printPreorder(root); 
+  
+    cout << "\nInorder traversal of binary tree is \n"; 
+    printInorder(root);  
+  
+    cout << "\nPostorder traversal of binary tree is \n"; 
+    printPostorder(root); 
+  
+    return 0; 
+} 

Tree/Tree Traversal/DFS/C++/DFS.cpp

@@ -0,0 +1,38 @@
+#include <iostream>
+using namespace std;
+
+bool adj_matrix[101][101]={0};
+bool visited[101]={0};
+int n;
+
+void DFS(int s)
+{
+	visited[s]=1;
+	cout<<s<<" ";
+	for(int i=1;i<=n;i++)
+		if(adj_matrix[s][i]==1 && !visited[i])
+			DFS(i);
+}
+
+int main() 
+{
+	cout<<"Enter number of nodes: ";
+	cin>>n;
+	int m;
+    cout<<"Enter number of edges: ";
+	cin>>m;
+	cout<<"Enter edges starting from source node:\n";
+	for(int i=0;i<m;i++)
+	{
+		int x,y;
+		cin>>x>>y;
+		adj_matrix[x][y]=1;
+		
+	}
+	int s;
+	cout<<"Re-enter source node";
+	cin>>s;
+	cout<<"DFS with Source "<<s<<"\n";
+	DFS(s);
+	return 0;
+}

Tree/Tree Traversal/ReversalAlgo.cpp

@@ -0,0 +1,51 @@
+                           /*                           REVERSAL ALGORITHM FOR ARRAY ROTATION                             */
+
+#include <bits/stdc++.h> 
+using namespace std; 
+  
+/*Function to reverse arr[] from index start to end*/
+void rvereseArray(int arr[], int start, int end) 
+{ 
+    while (start < end) { 
+        int temp = arr[start]; 
+        arr[start] = arr[end]; 
+        arr[end] = temp; 
+        start++; 
+        end--; 
+    } 
+} 
+  
+/* Function to left rotate arr[] of size n by d */
+void leftRotate(int arr[], int d, int n) 
+{ 
+    if (d == 0) 
+        return; 
+    rvereseArray(arr, 0, d - 1); 
+    rvereseArray(arr, d, n - 1); 
+    rvereseArray(arr, 0, n - 1); 
+} 
+  
+// Function to print an array 
+void printArray(int arr[], int size) 
+{ 
+    for (int i = 0; i < size; i++) 
+        cout << arr[i] << " "; 
+} 
+  
+/* Driver program to test above functions */
+int main() 
+{ 
+    int arr[] = { 1, 2, 3, 4, 5, 6, 7 }; 
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    int d = 2; 
+  
+    // in case the rotating factor is 
+    // greater than array length 
+    d = d % n; 
+  
+    // Function calling 
+    leftRotate(arr, d, n); 
+    printArray(arr, n); 
+  
+    return 0; 
+}