Merge pull request #1 from amritansh22/master

update

Author: YUVRAJMOTWANI99

Diff for: Binary Matrix.cpp

@@ -0,0 +1,27 @@
+#include<iostream>
+#include<algorithm>
+#include<math.h>
+#include<vector>
+using namespace std;
+int main()
+{
+    int n,m;
+    cin>>n>>m;
+    string s[n],s1[n];
+    for(int i=0;i<n;i++)
+    {
+        cin>>s[i];
+        s1[i]=s[i];
+    }
+    sort(s,s+n,greater<string>());
+    string temp=s[0];
+    for(int i=0;i<n;i++)
+    {
+        if(s1[i]==temp)
+        {cout<<i+1<<endl;
+            break;
+        }
+    }
+    
+    
+}

Diff for: BinarySearchTree.cpp

@@ -0,0 +1,185 @@
+//Implement Binary Search Tree and Perform Operations : Insertion, Deletion, Searching (Issue #107)
+//https://github.com/amritansh22/Data-Structures-and-Algorithms-in-cpp/issues/107
+//Contributed by @tauseefmohammed2 : https://github.com/tauseefmohammed2
+
+#include<iostream>
+using namespace std;
+
+class BinarySearchTree {
+    
+    struct BSTnode {
+        int data;
+        BSTnode* left;
+        BSTnode* right;
+    };
+
+    BSTnode* root;
+
+    //Function to Clear a Node
+    BSTnode* clear(BSTnode* t) {
+        if(t == NULL)
+            return NULL;
+        {
+            clear(t->left);
+            clear(t->right);
+            delete t;
+        }
+        return NULL;
+    }
+
+    //Function to Insert a Node
+    BSTnode* insert(int x, BSTnode* t)
+    {
+        if(t == NULL)
+        {
+            t = new BSTnode;
+            t->data = x;
+            t->left = t->right = NULL;
+        }
+        else if(x < t->data)
+            t->left = insert(x, t->left);
+        else if(x > t->data)
+            t->right = insert(x, t->right);
+        return t;
+    }
+
+    //Function to Obtain the Node with the Minimum Value
+    BSTnode* min(BSTnode* t)
+    {
+        if(t == NULL)
+            return NULL;
+        else if(t->left == NULL)
+            return t;
+        else
+            return min(t->left);
+    }
+
+    //Function to Obtain the Node with the Maximum Value
+    BSTnode* max(BSTnode* t) {
+        if(t == NULL)
+            return NULL;
+        else if(t->right == NULL)
+            return t;
+        else
+            return max(t->right);
+    }
+
+    //Function to Delete/Remove a Node from the BST
+    BSTnode* remove(int x, BSTnode* t) {
+        BSTnode* temp;
+        if(t == NULL)
+            return NULL;
+        else if(x < t->data)
+            t->left = remove(x, t->left);
+        else if(x > t->data)
+            t->right = remove(x, t->right);
+        else if(t->left && t->right)
+        {
+            temp = min(t->right);
+            t->data = temp->data;
+            t->right = remove(t->data, t->right);
+        }
+        else
+        {
+            temp = t;
+            if(t->left == NULL)
+                t = t->right;
+            else if(t->right == NULL)
+                t = t->left;
+            delete temp;
+        }
+
+        return t;
+    }
+
+    //Function to Display Inorder Traversal of the BST
+    void inorder_traversal(BSTnode* t) {
+        if(t == NULL)
+            return;
+        inorder_traversal(t->left);
+        cout << t->data << " ";
+        inorder_traversal(t->right);
+    }
+
+    //Function to Search and Check whether a Given Node is Present in the BST or Not
+    BSTnode* search(BSTnode* t, int x) {
+        if(t == NULL)
+            return NULL;
+        else if(x < t->data)
+            return search(t->left, x);
+        else if(x > t->data)
+            return search(t->right, x);
+        else
+            return t;
+    }
+
+public:
+    //Creating Corresponding Functions for the Object to Acccess Outside the Class
+    BinarySearchTree() {
+        root = NULL;
+    }
+
+    ~BinarySearchTree() {
+        root = clear(root);
+    }
+
+    void insert(int x) {
+        root = insert(x, root);
+    }
+
+    void remove(int x) {
+        root = remove(x, root);
+    }
+
+    void display() {
+        inorder_traversal(root);
+        cout << endl;
+    }
+
+    void search(int x) {
+        root = search(root, x);
+        if(root == NULL)
+            cout << endl << x <<" is Not Present in the BST";
+        else
+            cout<< endl << x <<" is Present in the BST";
+    }
+};
+
+int main() {
+    //Creating Object of BinarySearchTree Class
+    BinarySearchTree t;
+
+    //Inserts the Following Nodes into the BST
+    t.insert(20);
+    t.insert(25);
+    t.insert(15);
+    t.insert(10);
+    t.insert(30);
+
+    //Displays Inorder Traversal of BST
+    t.display();
+
+    //Remove 20 and 25 From the BST and Display Corresponding Inorder Traversal
+    t.remove(20);
+    t.display();
+    t.remove(25);
+    t.display();
+    
+    t.search(15);
+    return 0; 
+}
+
+//Output :
+//10 15 20 25 30                                                                                                          
+//10 15 25 30                                                                                                             
+//10 15 30                                                                                                                                                                                                                                      
+//15 is Present in the BST                                                                                                 
+//20 is Not Present in the BST
+
+//Time Complexity :
+//Insertion : O(h) [h = Height of BST]
+//Deletion : O(h) [h = Height of BST]
+//Searching : O(h) [h = Height of BST]
+
+//Space Complexity :
+//O(n) [n = Number of Nodes in BST]

Diff for: ExtendedEuclidean.cpp

@@ -0,0 +1,29 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int extended_Euclidean(int a, int b, int* x, int *y){
+
+    if(a == 0){
+    	*y = 1;
+        *x = 0;
+        return b;
+    }
+
+    else {
+    	int x1, y1;
+	    int gcd = extended_Euclidean(b%a, a, &x1, &y1);
+	    *x = y1 - (b/a) * x1;
+	    *y = x1; 
+	    return gcd;
+    }
+}
+
+int main(){
+	
+    int x, y, n1, n2;
+    cin >> n1 >> n2;
+
+    int gcd = extended_Euclidean(n1, n2, &x, &y);
+
+    printf("(%d)*%d + (%d)*%d = %d", x, n1, y, n2, gcd);   
+}

Diff for: Find length circular linked list.cpp

@@ -0,0 +1,52 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+struct Node { 
+	int data; 
+	struct Node* next; 
+}; 
+
+void push(struct Node** head_ref, int data) 
+{ 
+	struct Node* ptr1 = (struct Node*)malloc(sizeof(struct Node)); 
+	struct Node* temp = *head_ref; 
+	ptr1->data = data; 
+	ptr1->next = *head_ref; 
+
+	if (*head_ref != NULL) { 
+		while (temp->next != *head_ref) 
+			temp = temp->next; 
+		temp->next = ptr1; 
+	} else
+		ptr1->next = ptr1; 
+
+	*head_ref = ptr1; 
+} 
+
+int countNodes(struct Node* head) 
+{ 
+	struct Node* temp = head; 
+	int result = 0; 
+	if (head != NULL) { 
+		do { 
+			temp = temp->next; 
+			result++; 
+		} while (temp != head); 
+	} 
+
+	return result; 
+} 
+
+int main() 
+{ 
+	struct Node* head = NULL; 
+	push(&head, 12); 
+	push(&head, 56); 
+	push(&head, 2); 
+	push(&head, 11); 
+
+	printf("%d", countNodes(head)); 
+
+	return 0; 
+} 
+

Diff for: Reverse an array.cpp

@@ -0,0 +1,29 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+	int n;
+	cin>>n;
+	int arr[n];
+	for (int i=0;i<n;i++){
+		cin>>arr[i];
+	}
+	
+	int start=0, end=n-1;
+	
+	while(end>start){
+		int temp=arr[start];
+		arr[start]=arr[end];
+		arr[end]=temp;
+		start++;
+		end--;
+	}
+	
+	for (int i=0;i<n;i++){
+		cout<<arr[i]<<" ";
+	}
+	
+	
+	
+	return 0;
+}