From fb320e37dbf542ae43fa6b75bf34fbf0ef17764c Mon Sep 17 00:00:00 2001
From: Tarun Srivastava <120120552+Lord-Morpheus@users.noreply.github.com>
Date: Sat, 7 Oct 2023 14:19:47 +0530
Subject: [PATCH 1/2] new subfolder added #6

contains prims algorithm under greedy subfolder
---
 .../Greedy/prim's_algorithm.cpp               | 136 ++++++++++++++++++
 1 file changed, 136 insertions(+)
 create mode 100644 Computational_Algorithms/Greedy/prim's_algorithm.cpp

diff --git a/Computational_Algorithms/Greedy/prim's_algorithm.cpp b/Computational_Algorithms/Greedy/prim's_algorithm.cpp
new file mode 100644
index 0000000..4f10a9f
--- /dev/null
+++ b/Computational_Algorithms/Greedy/prim's_algorithm.cpp
@@ -0,0 +1,136 @@
+/*PRIM'S ALGORITHM FOR MINIMUM SPANNING TREE*/
+
+/*if we have a graph whose nodes are connected to each other acyclic or cyclic and the paths have some
+  weight then we can find out the minimum weighted path which connects all node.
+*/
+
+/* OBSERVATIONS-
+  1)if there are n nodes then there will be n-1 paths which connects all nodes.
+  2)if we have 2 non connected graph then we can never find minimum spanning path using this algo.
+*/
+
+/*ALGORITHM
+    1)create three arrays parent,weight,visited.
+    2)initialise weight vector with max value and visited vector with false.
+    3)we can start with any node(usually node 0) then select node whose path with this node is least
+      and update the parent for this node.
+    4)as we select paths we will also update weights in weight array with minimum of weights 
+      and value stored in weights array.
+    5)once we have visited the node we update value in visited array as true.
+    6)we then select minimum value in array weights and repeat step 4-6 till we get parent of
+      each node filled.
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+
+//finding node with minimum value of weight.
+int node(vector<int>& weight,vector<bool>& visited,int V)
+{
+	int minimum = INT_MAX;
+	int vertex;
+	for(int i=0;i<V;++i)
+	{
+		if(visited[i]==false && weight[i]<minimum)
+		{
+			vertex = i;
+			minimum = weight[i];
+		}
+	}
+	return vertex;
+}
+
+//creating a spanning tree.
+void spanningTree(vector<vector<int>> graph,int V)
+{
+	int parent[V];// creating parent array.
+	vector<int> weight(V,INT_MAX);// setting weight of each node initially maximum/infinity.
+	vector<bool> visited(V,false);// setting initial visited array as false none visited.
+
+
+	parent[0] = -1;	//as we are taking 0 is base node so it will have no parent
+	weight[0] = 0;	//cost of going to node 0 from node 0 would be 0
+
+
+	for(int i=0;i<V-1;i++)
+	{	
+		int U = node(weight,visited,V);
+		visited[U] = true;	
+
+		for(int j=0;j<V;j++)
+		{
+			if(graph[U][j]!=0 && visited[j]==false && graph[U][j]<weight[j])
+			{
+				weight[j] = graph[U][j];
+				parent[j] = U;
+			}
+		}
+	}
+
+	int cost=0;
+
+	for(int i=1;i<V;i++){
+		cout<<"nodes connected: "<<parent[i]<<"->"<<i<<"  weight = "<<graph[parent[i]][i]<<endl;
+		cost+=graph[parent[i]][i];
+	}
+	cout<<"cost of traversing spanning tree is "<<cost<<endl;
+}
+
+int main()
+{
+    int V;
+    cout<<"enter number of vertices/nodes."<<endl;
+    cin>>V;
+
+    vector<vector<int>> graph(V,vector<int>(V));
+    
+    int n;
+    cout<<"enter number of edges"<<endl;
+    cin>>n;
+
+    for (int i = 0; i <n ; i++)
+    {
+        int p,q;
+        cout<<"enter the connecting nodes and weight of path in order node1,node2 and path weight"<<endl;
+        cin>>p>>q;
+        if(p<0||p>V-1||q<0||q>V-1){
+			cout<<"please keep input in range."<<endl;
+			return 0;
+		}
+
+		int val;
+		cout<<"enter the weight of path"<<endl;
+		cin>>val;
+		graph[p][q]=val;
+		graph[q][p]=val;
+    }
+    
+	/* adjacency matrix for inputs-
+		6 10
+		0 1 4
+		0 2 6
+		1 2 6
+		1 3 3 
+		1 4 4
+		2 4 8 
+		4 5 7
+		2 3 1
+		3 4 2 
+		3 5 3
+
+		would look like this-
+
+	   [[0, 4, 6, 0, 0, 0],
+		[4, 0, 6, 3, 4, 0],
+		[6, 6, 0, 1, 8, 0],
+		[0, 3, 1, 0, 2, 3],
+		[0, 4, 8, 2, 0, 7],
+		[0, 0, 0, 3, 7, 0]]
+    */
+
+	spanningTree(graph,V);	
+	return 0;
+}
+
+//TIME COMPLEXITY: O(V^2) but can be improved further like if we 
+//				   would have used adjacency list instead of matrix.
\ No newline at end of file

From be90b16467c5b5eab81cae6e6864e73846321ca8 Mon Sep 17 00:00:00 2001
From: Tarun Srivastava <120120552+Lord-Morpheus@users.noreply.github.com>
Date: Sat, 7 Oct 2023 14:23:51 +0530
Subject: [PATCH 2/2] Delete Computational_Algorithms/Trees directory

---
 .../Trees/Order_Traversal.cpp                 | 139 ------------------
 .../Trees/Segment_Tree.cpp                    |  89 -----------
 2 files changed, 228 deletions(-)
 delete mode 100644 Computational_Algorithms/Trees/Order_Traversal.cpp
 delete mode 100644 Computational_Algorithms/Trees/Segment_Tree.cpp

diff --git a/Computational_Algorithms/Trees/Order_Traversal.cpp b/Computational_Algorithms/Trees/Order_Traversal.cpp
deleted file mode 100644
index 80ecd66..0000000
--- a/Computational_Algorithms/Trees/Order_Traversal.cpp
+++ /dev/null
@@ -1,139 +0,0 @@
-/*BINARY TREE ORDER TRAVERSAL(DFS Traversal)*/
-
-/*Traversing tree in different orders-
-    preorder is <root><left><right> traversal in order
-    inorder is <left><root><right> traversal in order
-    postorder is <left><right><node> traversal in order
-*/
-
-/*TREE 
-                        0
-                       / \
-                      1   2
-                     / \ / \
-                     ....... so on
-*/
-
-//formation of tree
-#include<bits/stdc++.h>
-using namespace std;
-struct binary_Tree
-{
-    int val;
-    binary_Tree* left;
-    binary_Tree* right;
-};
-
-/*PREORDER ALGORITHM IS
-    1)if you point to a root.. print it
-    2)move left if it exists 
-    3)move right if it exists
-    4)do this till you have traversed the complete tree
-*/
-
-/*FOR TREE-
-                        A
-                       / \
-                      /   \
-                     B     C
-                    / \   / \
-                   D   E  F  G
-                   \     /   /
-                    H   I   J
-    
-    PREORDER = A,B,D,H,E,C,F,I,G,J
-*/
-void preorder(binary_Tree* root){
-    if(root==NULL){
-        return;
-    }
-    cout<<root->val<<' ';//printing the value
-    preorder(root->left);//moving left
-    preorder(root->right);//moving right
-}
-
-/*FOR TREE-
-                        A
-                       / \
-                      /   \
-                     B     C
-                    / \   / \
-                   D   E  F  G
-                   \     /   /
-                    H   I   J
-    
-    inorder=D,H,B,E,A,I,F,C,J,G
-    -if you know concept of binary tree you will see that this 
-     arrangement is in ascending order.
-*/
-void inorder(binary_Tree* root){
-    if(root==NULL){
-        return;
-    }
-    inorder(root->left);//moving left
-    cout<<root->val<<' ';//printing the value
-    inorder(root->right);//moving right
-}
-
-/*FOR TREE-
-                        A
-                       / \
-                      /   \
-                     B     C
-                    / \   / \
-                   D   E  F  G
-                   \     /   /
-                    H   I   J
-    
-    postorder= H,D,E,B,I,F,J,G,C,A
-*/
-void postorder(binary_Tree* root){
-    // cout<<"postorder is: ";
-    if(root==NULL){
-        return;
-    }
-    postorder(root->left);//moving left
-    postorder(root->right);//moving right
-    cout<<root->val<<' ';//printing the value
-}
-
-
-//assuming you know insertion in binary tree
-binary_Tree* insert(binary_Tree*root,int value){
-    if(root==NULL){
-       binary_Tree* newNode=new binary_Tree();
-       root=newNode;
-       newNode->val=value;
-    }
-    else if(value<=root->val){
-        root->left=insert(root->left,value);
-    }
-    else if(value>root->val){
-        root->right=insert(root->right,value);
-    }
-    return root;
-}
-
-int main(){
-    binary_Tree* root=NULL;
-    int n;
-    cout<<"enter number of nodes to be added"<<endl;
-    cin>>n;
-    for (int i = 0; i < n; i++)
-    {
-        int a;
-        cout<<"enter element to be inserted"<<endl;
-        cin>>a;
-        root=insert(root,a);
-    }
-    cout<<"preorder is: ";
-    preorder(root);
-    cout<<endl;
-    cout<<"inorder is: ";
-    inorder(root);
-    cout<<endl;
-    cout<<"postorder is: ";
-    postorder(root);
-
-    return 0;
-}
\ No newline at end of file
diff --git a/Computational_Algorithms/Trees/Segment_Tree.cpp b/Computational_Algorithms/Trees/Segment_Tree.cpp
deleted file mode 100644
index e8df8cd..0000000
--- a/Computational_Algorithms/Trees/Segment_Tree.cpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/*SEGMENT TREE*/
-/*Segment Trees are pre-computational algorithms used to reduce time comlexity.*/
-
-/*SENARIO: we want to find min and max value in a given range of an array*/
-/*algorithm:
-    1) create an empty array of size = 4*(size of input array)
-        reason for this is at max there will be these many number of indexes.
-    2) divide the array about middle index till you get single index for a section.
-    3) as you move above the tree keep updating values for parent node as per condtion
-    4) you will get desired tree.
-*/
-
-/* TREE WILL LOOK LIKE THIS FOR SAY LENGTH OF ORIGINAL ARRAY IS 5
-                            [0-5]
-                            /    \
-                           /       \
-                        [0-2]       [3-5]
-                        /   \        /    \
-                    [0-1]   [2-2]   [3-4]  [5-5]
-                    /   \           /    \
-                [0-0]   [1-1]      [3-3]  [4-4]
-
-    THESE ARE THE INDEXES SPECIFIED
-*/
-
-
-//this code is for finding min/max in a section of an arrray using segment tree but we can 
-//also rectify it for finding sum in a section of an arrray using segment tree.
-
-//time complexity is O(log n) for finding and O(n) for creating the tree
-//space complexity is O(4*n) i.e. o(n)
-
-#include<bits/stdc++.h>
-using namespace std;
-
-vector<int>arr(100005);//initializing with large space just to ensure that array is inside it.
-
-vector<int>segment((arr.size())*4);
-
-void tree(int node,int lowerIndex,int higherIndex){
-    if(lowerIndex==higherIndex){
-        segment[node]=arr[lowerIndex];
-        return;
-    }
-    int mid=(lowerIndex+higherIndex)/2;
-    tree(node*2+1,lowerIndex,mid);
-    tree(node*2+2,mid+1,higherIndex);
-    segment[node]=max(segment[node*2+1],segment[node*2+2]);
-}
-
-/*TO FIND THE MIN/MAX VALUE IN A PART OF */
-int find(int node,int low,int high,int l,int r){
-    //here l and r is the range in which we want to find the min/max value
-    if(l<=low&&r>=high){
-        return segment[node];
-    }
-    if(l>high||r<low)return INT_MIN;
-    int mid=(low+high)/2;
-    int first=find(2*node+1,low,mid,l,r);
-    int second=find(2*node+2,mid+1,high,l,r);
-    return max(first,second);
-}
-int main(){
-    
-    //remember initiating array here is not a good practice as it servers no purpose 
-    //of precomputation hence always initiate it at begining as a global array.
-
-    int n;//will fill only n spaces out of complete max size.
-    cout<<"enter size of the array"<<endl;
-    cin>>n;
-    cout<<"enter values of elements of array"<<endl;
-    for (int i = 0; i < n; i++)
-    {
-        cin>>arr[i];
-    }
-    
-    tree(0,0,n-1);//to build the tree
-    cout<<"value of range minimum index and maximum index"<<endl;
-    int l,r;
-    cin>>l>>r;
-    if(l<0||r>n-1){
-        cout<<"out of index please keep input in array range";
-        return 0;
-    }
-    int result=find(0,0,n-1,l,r);//to find the min/max value in a given range.
-    if(result==INT_MIN){cout<<"range out of index";}
-    else cout<<result;
-    return 0;
-}