Merge branch 'smv1999:master' into master

Author: ushmita4

Arrays/max_and_min_element.cpp

@@ -0,0 +1,67 @@
+// Problem Description:
+//   Here, we have an array arr[]. The array contains n integer values.
+//   We have to find the maximum value and minimum value out of all values of the array.
+
+//   Let’s take an example to understand the problem
+
+//   Input  : n = 5
+//            a[n] = { 10, 20, 30, 40, 50}
+
+//   Output :  Maximum element of array is 50
+//             Minimum element of array is 10
+
+// Explanation : 
+//
+// There can be multiple solution for this problem. 
+// One solution is to directly compare the elements of  array. This can be done by using two different approaches :
+//      1.Iterative approach  
+//      2.Recursive approach 
+
+// Here we are using iterative approach to solve this problem. 
+// initially we will set a[0] as min/max. Then we iterate over each elemnts using loop and compare it with max/min element of array. 
+
+// Time Complexity  : O(n)
+// Space Complexity : O(1)
+
+#include <iostream>
+using namespace std;
+
+int getmax( int a[], int n){
+    int max = a[0];
+    for( int i=1; i<n; i++)
+    {
+        if( a[i] > max )
+           max = a[i];
+    }
+
+    return max;
+}
+
+int getmin( int a[], int n){
+    int min = a[0];
+    for( int i=1; i<n; i++)
+    {
+        if( a[i] < min )
+           min = a[i];
+    }
+
+    return min;
+}
+
+int main()
+{
+   int n;
+   cin>>n;
+   int a[n];
+   for( int i=0; i<n; i++)
+   {
+       cin>>a[i];
+   }
+   int max = getmax( a, n);
+   int min = getmin( a, n);
+   cout<<"Maximum element of array is :"<<max<<endl;
+   cout<<"Minimum element of array is :"<<min<<endl;
+
+}
+
+

Backtracking/Hamiltonian_Cycle.py

@@ -0,0 +1,109 @@
+'''
+Hamiltonian Path: a Hamiltonian path (or traceable path) is a path
+    in an undirected or directed graph that visits each vertex exactly
+    once. A Hamiltonian cycle (or Hamiltonian circuit) is a Hamiltonian
+    path that is a cycle.
+Aim: To determine the existance of a Hamiltonian Cycle in the provided
+        undirected graph and return the path if such path exist.
+        The nodes are numbered from 1 to N.
+
+'''
+
+from collections import defaultdict
+
+
+def Move_next_node(n, graph, pos, ans):
+    # Base Case: If all the node is visited:
+    if pos == n:
+
+        # Check wether the last node and the first node are
+        # connected in order to form a Cycle
+        if ans[0] in graph[ans[-1]]:
+            return ans + [ans[0]]
+
+        return False
+
+    current = ans[-1]
+
+    # Check for each of the adjoining vertices
+    for i in graph[current]:
+
+        # Check wether the node is already visited or not
+        if i not in ans:
+            ans += [i]
+            temp = Move_next_node(n, graph, pos + 1, ans)
+            if temp:
+                return temp
+
+            ans.pop()
+
+    return False
+
+
+def Hamiltonial_Cycle(n, graph):
+    # To keep a track of already visited node and the answer
+    # We will start exploring the graph from Vertex 1
+    answer = [1]
+
+    # Start Exploring adjoining node/vertex
+    return Move_next_node(n, graph, 1, answer)
+
+
+# ------------------------DRIVER CODE ------------------------
+if __name__ == "__main__":
+    n, m = map(int, input("Enter the number of vertex and edges: ").split())
+    print("Enter the edges: ")
+    graph = defaultdict(list)
+    for i in range(m):
+        a, b = map(int, input().split())
+        graph[a] += [b]
+        graph[b] += [a]
+    ans = Hamiltonial_Cycle(n, graph)
+    if not ans:
+        print("Hamiltonian Cycle is not possible in the Given graph")
+    else:
+        print("Hamiltonian Cycle is possible in the graph")
+        print("The path is : ", *ans)
+
+'''
+
+Sample Working:
+    
+     5----1------2
+    /\     \    /
+   /  \     \  /
+  /    \     \/
+ 3------6-----4
+Enter the number of vertex and edges: 6 8
+Enter the edges
+5 1
+1 2
+1 4
+5 6
+6 4
+4 2
+3 6
+5 3
+Hamiltonian Cycle is possible in the graph
+The path is :  1 5 3 6 4 2 1
+     5----1------2
+     \     \
+      \     \
+       \     \
+ 3------6-----4
+Enter the number of vertex and edges: 6 6
+Enter the edges:
+5 1
+3 6
+6 4
+1 2
+5 6
+1 4
+Hamiltonian Cycle is not possible in the Given graph
+
+COMPLEXITY:
+    
+     Time Complexity ->  O(2^N)
+     Space Complexity -> O(N)
+     
+'''

Data Structures/Graphs/WarshallAlgorithm.py

@@ -0,0 +1,74 @@
+'''
+A program for warshall algorithm.It is a shortest path algorithm which is used to find the 
+distance from source node,which is the first node,to all the other nodes.
+If there is no direct distance between two vertices then it is considered as -1
+'''
+
+
+def warshall(g,ver):
+    dist = list(map(lambda i: list(map(lambda j: j, i)), g))
+    for i in range(0,ver):
+        for j in range(0,ver):
+            dist[i][j] = g[i][j]
+	#Finding the shortest distance if found
+    for k in range(0,ver):
+        for i in range(0,ver):
+            for j in range(0,ver):
+                if dist[i][k] + dist[k][j] < dist[i][j] and  dist[i][k]!=-1 and dist[k][j]!=-1:
+                    dist[i][j] = dist[i][k] + dist[k][j]
+	#Prnting the complete short distance matrix
+    print("The distance matrix is\n")
+    for i in range(0,ver):
+        for j in range(0,ver):
+            if dist[i][j]>=0:
+                print(dist[i][j],end=" ")
+            else:
+                print(-1,end=" ")
+        print("\n")
+#Driver's code
+def main():
+    print("Enter number of vertices\n")
+    ver=int(input())
+    graph=[]
+	#Creating the  graph
+    print("Enter the graph\n")
+    for i in range(ver):
+        a =[]
+        for j in range(ver):     
+            a.append(int(input()))
+        graph.append(a)
+    warshall(graph,ver)
+if __name__=="__main__":
+	main()
+
+
+
+'''
+Time Complexity:O(ver^3)
+Space Complexity:O(ver^2)
+Input/Output:
+Enter number of vertices 
+4
+Enter the graph
+0
+8
+-1
+1
+-1
+0
+1
+-1
+4
+-1
+0
+-1
+-1
+2
+9
+0
+The distance matrix is
+0 3 -1 1 
+-1 0 1 -1 
+4 -1 0 -1 
+-1 2 3 0 
+'''

Data Structures/Linked Lists/Remove_all_Duplicates_from_Linnkedlist.cpp

@@ -0,0 +1,98 @@
+/*
+Given the Sorted Linked list head which contain duplicates, the task is
+to delete all the duplicate and make linked list such that every element
+appear just one time.
+Example:
+Original Linked list : 1 1 2 2 3
+Answer : 1 2 3
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+// A linked list node
+class Node
+{
+    public:
+    int data;
+    Node *next;
+};
+
+// Utility function to create a new Node
+void push(Node **head, int n_data)
+{
+    Node *newdata = new Node();
+    newdata->data = n_data;
+    newdata->next = (*head);
+    (*head) = newdata;
+}
+
+// Function to print nodes in a given linked list. 
+void printlinkedlist(Node *temp)
+{
+    while (temp != NULL)
+    {
+        cout << "->" << temp->data;
+        temp = temp->next;
+    }
+}
+
+// Function to delete duplicate nodes
+Node *delete_duplicates(Node *head)
+{
+    //initalize current to head
+    Node *curr = head;
+    // when curr and curr->next is not NULL
+    // enter the loop
+    while (curr && curr->next)
+    {
+        // if the adjacent nodes are found to be equal
+        if (curr->next->data == curr->data)
+        {
+            // then point the curr->next to one step ahead
+            // to the existing pointer.
+            curr->next = curr->next->next;
+        }
+        else
+        {
+            // Until the current and current->next values are 
+            // not same, keep updating current
+            curr = curr->next;
+        }
+    }
+    return head;
+}
+int main()
+{
+    Node *head = NULL;
+    int n;
+    cout << "Enter number of Elements:";
+    cin >> n;
+    cout << "Enter elements:";
+    for (int i = 0; i < n; i++)
+    {
+        int a;
+        cin >> a;
+        push(&head, a);
+    }
+    cout <<"Original Linked list:\n";
+    printlinkedlist(head);
+    cout <<"\nNew Linked List:\n";
+    head = delete_duplicates(head);
+    printlinkedlist(head);
+}
+
+/*
+Sample Input:
+Enter number of Elements:5
+Enter elements:1 1 2 2 3
+
+Sample Output:
+Original Linked list:
+->3->2->2->1->1
+New Linked List:
+->3->2->1
+
+Time-Complexity: O(n)
+Space-Complexity: O(1)
+*/