Added Multiple Algorithms, Updated Readme, Restructure Few Directories

Algorithms/General_Algorithms/Minimum Subarray/minimum_elements_with_difference_one_or_zero.ipynb → Algorithms/General_Algorithms/Minimum Subarray/Minimum_elements_with_difference_one_or_zero.ipynb

@@ -54,4 +54,4 @@
       ]
     }
   ]
-}
+}

Algorithms/General_Algorithms/SieveOfEratosthenes/Shubh.c → Algorithms/General_Algorithms/SieveOfEratosthenes/Seive of Eratosthenes2.c

@@ -46,4 +46,4 @@ int main(void)
 
 
 
-}
+}

Algorithms/Greedy_Algorithms/knapsack_problem_in_oops.py → Algorithms/Greedy_Algorithms/knapsack_problem(Using Object Oriented Programming).py

@@ -40,4 +40,4 @@ def get_max(weights,values):
 weights=[10,40,20,30]
 values=[60,40,100,120]
 max_value=final_value.get_max(weights,values)
-print(max_value)
+print(max_value)

Algorithms/Searching_Algorithms/Binary Search/perfect_square.ipynb → Algorithms/Searching_Algorithms/Binary Search/Perfect_square using Binary Search.ipynb

@@ -72,4 +72,4 @@
       ]
     }
   ]
-}
+}

Algorithms/Sorting_Algorithms/Bubble_Sort/bubbleSort.py

@@ -0,0 +1,25 @@
+def bubbleSort(arr): 
+    n = len(arr) 
+
+    # Traverse through all array elements 
+    for i in range(n-1): 
+    # range(n) also work but outer loop will repeat one time more than needed. 
+
+        # Last i elements are already in place 
+        for j in range(0, n-i-1): 
+
+            # traverse the array from 0 to n-i-1 
+            # Swap if the element found is greater 
+            # than the next element 
+            if arr[j] > arr[j+1] : 
+                arr[j], arr[j+1] = arr[j+1], arr[j] 
+
+# Driver code to test above 
+arr = []
+arr = [int(item) for item in input().split()]  
+
+bubbleSort(arr) 
+
+print ("Sorted array is:") 
+for i in range(len(arr)): 
+    print ("%d" %arr[i])  

Algorithms/Sorting_Algorithms/Merge Sort/Merge_Sort.py

@@ -0,0 +1,70 @@
+def merge(arr, l, m, r): 
+    n1 = m - l + 1
+    n2 = r- m 
+
+    # create temp arrays 
+    L = [0] * (n1) 
+    R = [0] * (n2) 
+
+    # Copy data to temp arrays L[] and R[] 
+    for i in range(0 , n1): 
+        L[i] = arr[l + i] 
+
+    for j in range(0 , n2): 
+        R[j] = arr[m + 1 + j] 
+
+    # Merge the temp arrays back into arr[l..r] 
+    i = 0     # Initial index of first subarray 
+    j = 0     # Initial index of second subarray 
+    k = l     # Initial index of merged subarray 
+
+    while i < n1 and j < n2 : 
+        if L[i] <= R[j]: 
+            arr[k] = L[i] 
+            i += 1
+        else: 
+            arr[k] = R[j] 
+            j += 1
+        k += 1
+
+    # Copy the remaining elements of L[], if there 
+    # are any 
+    while i < n1: 
+        arr[k] = L[i] 
+        i += 1
+        k += 1
+
+    # Copy the remaining elements of R[], if there 
+    # are any 
+    while j < n2: 
+        arr[k] = R[j] 
+        j += 1
+        k += 1
+
+# l is for left index and r is right index of the 
+# sub-array of arr to be sorted 
+def mergeSort(arr,l,r): 
+    if l < r: 
+
+        # Same as (l+r)//2, but avoids overflow for 
+        # large l and h 
+        m = (l+(r-1))//2
+
+        # Sort first and second halves 
+        mergeSort(arr, l, m) 
+        mergeSort(arr, m+1, r) 
+        merge(arr, l, m, r) 
+
+
+# Driver code to test above
+arr = []
+arr = [int(item) for item in input().split()] 
+n = len(arr) 
+print ("Given array is") 
+for i in range(n): 
+    print ("%d" %arr[i]), 
+
+mergeSort(arr,0,n-1) 
+print ("\n\nSorted array is") 
+for i in range(n): 
+    print ("%d" %arr[i]), 

Algorithms/Sorting_Algorithms/Radix Sort/Radix Sort.cpp

@@ -0,0 +1,76 @@
+// C++ implementation of Radix Sort
+#include <iostream>
+using namespace std;
+
+// A utility function to get maximum value in arr[]
+int getMax(int arr[], int n)
+{
+    int mx = arr[0];
+    for (int i = 1; i < n; i++)
+        if (arr[i] > mx)
+            mx = arr[i];
+    return mx;
+}
+
+// A function to do counting sort of arr[] according to
+// the digit represented by exp.
+void countSort(int arr[], int n, int exp)
+{
+    int output[n]; // output array
+    int i, count[10] = { 0 };
+
+    // Store count of occurrences in count[]
+    for (i = 0; i < n; i++)
+        count[(arr[i] / exp) % 10]++;
+
+    // Change count[i] so that count[i] now contains actual
+    //  position of this digit in output[]
+    for (i = 1; i < 10; i++)
+        count[i] += count[i - 1];
+
+    // Build the output array
+    for (i = n - 1; i >= 0; i--) {
+        output[count[(arr[i] / exp) % 10] - 1] = arr[i];
+        count[(arr[i] / exp) % 10]--;
+    }
+
+    // Copy the output array to arr[], so that arr[] now
+    // contains sorted numbers according to current digit
+    for (i = 0; i < n; i++)
+        arr[i] = output[i];
+}
+
+// The main function to that sorts arr[] of size n using
+// Radix Sort
+void radixsort(int arr[], int n)
+{
+    // Find the maximum number to know number of digits
+    int m = getMax(arr, n);
+
+    // Do counting sort for every digit. Note that instead
+    // of passing digit number, exp is passed. exp is 10^i
+    // where i is current digit number
+    for (int exp = 1; m / exp > 0; exp *= 10)
+        countSort(arr, n, exp);
+}
+
+// A utility function to print an array
+void print(int arr[], int n)
+{
+    for (int i = 0; i < n; i++)
+        cout << arr[i] << " ";
+}
+
+int main()
+{
+     int arr[1000];
+     for(int i=0;i<1000;i++){
+      cin>>arr[i];
+     }
+     int n = sizeof(arr) / sizeof(arr[0]);
+
+    // Function Call
+    radixsort(arr, n);
+    print(arr, n);
+    return 0;
+}

Algorithms/Sorting_Algorithms/Radix Sort/Radix Sort.java

@@ -0,0 +1,92 @@
+// Radix sort Java implementation
+import java.io.*;
+import java.util.*;
+
+class Radix {
+
+    // A utility function to get maximum value in arr[]
+    static int getMax(int arr[], int n)
+    {
+        int mx = arr[0];
+        for (int i = 1; i < n; i++)
+            if (arr[i] > mx)
+                mx = arr[i];
+        return mx;
+    }
+
+    // A function to do counting sort of arr[] according to
+    // the digit represented by exp.
+    static void countSort(int arr[], int n, int exp)
+    {
+        int output[] = new int[n]; // output array
+        int i;
+        int count[] = new int[10];
+        Arrays.fill(count, 0);
+
+        // Store count of occurrences in count[]
+        for (i = 0; i < n; i++)
+            count[(arr[i] / exp) % 10]++;
+
+        // Change count[i] so that count[i] now contains
+        // actual position of this digit in output[]
+        for (i = 1; i < 10; i++)
+            count[i] += count[i - 1];
+
+        // Build the output array
+        for (i = n - 1; i >= 0; i--) {
+            output[count[(arr[i] / exp) % 10] - 1] = arr[i];
+            count[(arr[i] / exp) % 10]--;
+        }
+
+        // Copy the output array to arr[], so that arr[] now
+        // contains sorted numbers according to curent digit
+        for (i = 0; i < n; i++)
+            arr[i] = output[i];
+    }
+
+    // The main function to that sorts arr[] of size n using
+    // Radix Sort
+    static void radixsort(int arr[], int n)
+    {
+        // Find the maximum number to know number of digits
+        int m = getMax(arr, n);
+
+        // Do counting sort for every digit. Note that
+        // instead of passing digit number, exp is passed.
+        // exp is 10^i where i is current digit number
+        for (int exp = 1; m / exp > 0; exp *= 10)
+            countSort(arr, n, exp);
+    }
+
+    // A utility function to print an array
+    static void print(int arr[], int n)
+    {
+        for (int i = 0; i < n; i++)
+            System.out.print(arr[i] + " ");
+    }
+
+    /*Driver Code*/
+    public static void main(String[] args)
+    {
+        Scanner s=new Scanner(System.in);
+
+        System.out.println("enter number of elements: ");
+        int n=s.nextInt();
+
+        int arr[]=new int[n];
+
+        System.out.println("Enter array elements: ");
+
+        for(int i=0;i<n;i++){
+            //for reading array
+            arr[i]=s.nextInt();
+
+        }
+
+        int n = arr.length;
+
+          // Function Call
+        radixsort(arr, n);
+        print(arr, n);
+    }
+}

Algorithms/Sorting_Algorithms/quick_sort/quick_sort_recursion.ipynb → Algorithms/Sorting_Algorithms/quick_sort/quick_sort_using_recursion.ipynb

@@ -58,4 +58,4 @@
       ]
     }
   ]
-}
+}