Merge pull request ABHISHEK-AMRUTE#104 from Sreejan-22/master

Create BucketSort.cpp

Author: ABHISHEK-AMRUTE

C++/BucketSort.cpp

@@ -0,0 +1,57 @@
+```
+/*
+Name: Sreejan Chaudhury
+College Name: University of Calcutta
+*/
+
+// Bucket sort is mainly useful when input is uniformly distributed over a range. For example, consider the following problem. 
+ 
+// C++ program to sort an array using bucket sort 
+#include <algorithm> 
+#include <iostream> 
+#include <vector> 
+using namespace std; 
+  
+// Function to sort arr[] of size n using bucket sort 
+void bucketSort(float arr[], int n) 
+{ 
+    // 1) Create n empty buckets 
+    vector<float> b[n]; 
+  
+    // 2) Put array elements in different buckets 
+    for (int i = 0; i < n; i++) { 
+        int bi = n * arr[i]; // Index in bucket 
+        b[bi].push_back(arr[i]); 
+    } 
+  
+    // 3) Sort individual buckets 
+    for (int i = 0; i < n; i++) 
+        sort(b[i].begin(), b[i].end()); 
+  
+    // 4) Concatenate all buckets into arr[] 
+    int index = 0; 
+    for (int i = 0; i < n; i++) 
+        for (int j = 0; j < b[i].size(); j++) 
+            arr[index++] = b[i][j]; 
+} 
+  
+/* Driver program to test above function */
+int main() 
+{ 
+    float arr[] = { 0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434 }; 
+    int n = sizeof(arr) / sizeof(arr[0]); 
+    bucketSort(arr, n); 
+  
+    cout << "Sorted array is \n"; 
+    for (int i = 0; i < n; i++) 
+        cout << arr[i] << " "; 
+    return 0; 
+}
+
+/*
+Output:
+
+Sorted array is
+0.1234 0.3434 0.565 0.656 0.665 0.897
+*/
+```

C++/ShellSort.cpp

@@ -0,0 +1,76 @@
+```
+/*
+Name: Sreejan Chaudhury
+College: University of Calcutta
+*/
+
+/* 
+ShellSort is mainly a variation of Insertion Sort. In insertion sort, we move elements only one position ahead. When an element has to be moved far ahead, 
+many movements are involved. The idea of shellSort is to allow exchange of far items. In shellSort, we make the array h-sorted for a large value of h. 
+We keep reducing the value of h until it becomes 1. An array is said to be h-sorted if all sublists of every h’th element is sorted.
+*/
+
+// C++ implementation of Shell Sort 
+#include  <iostream> 
+using namespace std; 
+
+/* function to sort arr using shellSort */
+int shellSort(int arr[], int n) 
+{ 
+    // Start with a big gap, then reduce the gap 
+    for (int gap = n/2; gap > 0; gap /= 2) 
+    { 
+        // Do a gapped insertion sort for this gap size. 
+        // The first gap elements a[0..gap-1] are already in gapped order 
+        // keep adding one more element until the entire array is 
+        // gap sorted  
+        for (int i = gap; i < n; i += 1) 
+        { 
+            // add a[i] to the elements that have been gap sorted 
+            // save a[i] in temp and make a hole at position i 
+            int temp = arr[i]; 
+  
+            // shift earlier gap-sorted elements up until the correct  
+            // location for a[i] is found 
+            int j;             
+            for (j = i; j >= gap && arr[j - gap] > temp; j -= gap) 
+                arr[j] = arr[j - gap]; 
+              
+            //  put temp (the original a[i]) in its correct location 
+            arr[j] = temp; 
+        } 
+    } 
+    return 0; 
+} 
+
+void printArray(int arr[], int n) 
+{ 
+    for (int i=0; i<n; i++) 
+        cout << arr[i] << " "; 
+} 
+  
+int main() 
+{ 
+    int arr[] = {12, 34, 54, 2, 3}, i; 
+    int n = sizeof(arr)/sizeof(arr[0]); 
+  
+    cout << "Array before sorting: \n"; 
+    printArray(arr, n); 
+  
+    shellSort(arr, n); 
+  
+    cout << "\nArray after sorting: \n"; 
+    printArray(arr, n); 
+  
+    return 0; 
+} 
+
+/*
+Output:
+
+Array before sorting:
+12 34 54 2 3
+Array after sorting:
+2 3 12 34 54
+*/
+```