Merge pull request #34 from Anirbansikder/second_branch

Added Other Sorting Algorithms (Count, Bucket, Heap)

Author: sadn1ck

src/SUMMARY.md

@@ -14,6 +14,9 @@
   - [Ternary Search](./Searching_Algos/Ternary_search/Explanation.md)
 - [Sorting Algorithms](./SortingAlgorithms/README.md)
   - [Quick Sort](./SortingAlgorithms/QuickSort.md)
+  - [Count Sort](./SortingAlgorithms/CountSort.md)
+  - [Bucket Sort](./SortingAlgorithms/BucketSort.md)
+  - [Heap Sort](./SortingAlgorithms/HeapSort.md)
   - [Radix Sort](./SortingAlgorithms/RadixSort.md)
   - [Insertion Sort](./SortingAlgorithms/InsertionSort/insertion.md)
   - [Merge Sort](./SortingAlgorithms/MergeSort/merge.md)

src/SortingAlgorithms/BucketSort.md

@@ -0,0 +1,99 @@
+# Bucket Sort
+
+## Example Problem
+
+Given an array ``arr = [a1,a2,a3,a4,a5...,an] `` , we need to sort the array with the help of Bucket Sort algorithm.
+
+<hr>
+
+## Discussion
+
+Bucket Sort is a sorting technique that sorts the elements by first dividing the elements into several groups called buckets. The elements inside each bucket are sorted using any of the suitable sorting algorithms or recursively calling the same algorithm.
+
+<hr>
+
+## Working of the Algorithm
+
+Several buckets are created. Each bucket is filled with a specific range of elements. The elements inside the bucket are sorted using any other algorithm. Finally, the elements of the bucket are gathered to get the sorted array.
+
+The process of bucket sort can be understood as a scatter-gather approach. The elements are first scattered into buckets then the elements of buckets are sorted. Finally, the elements are gathered in order.
+
+![Bucket Sort](https://cdn.programiz.com/sites/tutorial2program/files/Bucket_2.png)
+
+## Illustration
+
+Let's Sort an array of decimal numbers in th range 0 to 1.
+```
+Input array : 0.42 0.32 0.23 0.52 0.25 0.47 0.51
+
+Create an array of size 10. Each slot of this array is used as a bucket for storing elements.
+
+Insert elements into the buckets from the array. The elements are inserted according to the range of the bucket. And Sort them with a suitable sorting technique.
+
+Representation of the buckets ->
+
+|   |   | 0.23 |      | 0.42 | 0.51 |   |   |   |   |
+| 0 | 0 | 0.25 | 0.32 | 0.47 | 0.52 | 0 | 0 | 0 | 0 |
+  
+  0   1    2      3      4       5    6   7   8   9
+
+Traverse From Left to right and put the elements back into array in the same order.
+
+Sorted Array : 0.23 0.25 0.32 0.42 0.47 0.51 0.52
+```
+
+<hr>
+
+## Code
+
+### Code For Bucket Sort.
+```cpp
+void BucketSort(double a[],int n)
+{
+    // creating vector array of size 10
+    vector <double> bucket[10];
+
+    // putting elements in respective bucket
+    for(int i=0;i<n;i++)
+        bucket[ int(10 * a[i]) ].push_back(a[i]);
+    
+    // sorting each bucket with quick sort
+    for(int i=0;i<10;i++)
+        sort(bucket[i].begin(),bucket[i].end());
+
+    // picking from bucket and placing back to the array
+    for(int i=0, j=0;i<10;i++)
+    {
+        for(auto x : bucket[i])
+        {
+            a[j] = x;
+            j++;
+        }
+    }
+
+    // clearing the each bucket
+    for(int i=0;i<10;i++)
+        bucket[i].clear();
+}
+```
+<hr>
+
+## Time Complexity
+
+**Worst Case Complexity** : O ( n<sup>2</sup> )
+
+When there are elements of close range in the array, they are likely to be placed in the same bucket. This may result in some buckets having more number of elements than others.
+It makes the complexity depend on the sorting algorithm used to sort the elements of the bucket.
+
+The complexity becomes even worse when the elements are in reverse order. If insertion sort is used to sort elements of the bucket, then the time complexity becomes O ( n<sup>2</sup> ).
+
+**Best Case Complexity**: O(n+k)
+
+It occurs when the elements are uniformly distributed in the buckets with a nearly equal number of elements in each bucket.
+The complexity becomes even better if the elements inside the buckets are already sorted.
+
+If insertion sort is used to sort elements of a bucket then the overall complexity in the best case will be linear ie. O(n+k). O(n) is the complexity for making the buckets and O(k) is the complexity for sorting the elements of the bucket using algorithms having linear time complexity at the best case.
+
+<hr>
+
+Other Resources : [GFG Blog](https://www.geeksforgeeks.org/bucket-sort-2/)

src/SortingAlgorithms/CountSort.md

@@ -0,0 +1,101 @@
+# Count Sort
+
+## Example Problem
+
+Given an array `arr = [a1,a2,a3,a4,a5...,an] ` , we need to sort the array with the help of Count Sort algorithm.
+
+<hr>
+
+## Discussion
+
+Counting sort is a sorting technique based on keys between a specific range. It works by counting the number of objects having distinct key values. Then doing some arithmetic to calculate the position of each object in the output sequence.
+
+Take a count array of size ` max_element + 1` and initialise the array with 0 . Now iterate through the initial array and for each element x increase the value of count array at index x by 1.
+
+But this method won't work for negative integers .
+
+So we take a count array of size `max_element - min_element + 1` and initialize with 0. Now iterate through the initial array and for each element x increase the value of count array at index `x - min_element` by 1.
+
+Now Iterate through the count array and if value at the `index + min_element` is greater than 0 keep on adding the index value to the array , and decrement the value of the index by 1.
+
+<hr>
+
+## Working of the Algorithm
+
+```
+Consider array = [1 , 3 , -5 , 3 , 4 , -2 , 0]
+
+Here max_element = -5 and min_element = 4
+
+So, Create an array of size (4 - (-5) + 1) = 10 and initialise with 0.
+
+count_array = [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ]
+idx_values->    0   1   2   3   4   5   6   7   8   9
+
+After the iteration , count array becomes ->
+
+count_array = [ 1 , 0 , 0 , 1 , 0 , 1 , 1 , 0 , 2 , 1 ]
+idx_values->    0   1   2   3   4   5   6   7   8   9
+
+The Sorted Array becomes : [-5 , -2 , 0 , 1 , 3 , 3 , 4]
+```
+
+<hr>
+
+## Code
+
+### Code For Count Sort
+
+```cpp
+void CountSort(int a[],int n)
+{
+    int max_element = -INT_MAX , min_element = INT_MAX ;
+
+    // for finding the max_element in the array
+    for(int i=0;i<n;i++)
+        max_element = max(max_element , a[i]);
+    
+    // for finding the min_element in the array
+    for(int i=0;i<n;i++)
+        min_element = min(min_element , a[i]);
+
+    // initisalizing a count vector of size max_element - min_element + 1
+    vector <int> count(max_element - min_element +1 , 0);
+
+    // setting count vector according to the algorithm
+    for(int i=0;i<n;i++)
+        count[a[i] - min_element]++;
+    
+    // updating the actual array
+    int j = 0,i=0;
+    while(i<max_element - min_element +1)
+    {
+        if(count[i] == 0)
+            i++;
+        else
+        {
+            a[j] = min_element + i;
+            count[i]--;
+            j++;
+        }
+        
+    }
+}
+```
+
+<hr>
+
+## Time Complexity
+
+**Time Complexity**: O(n+k) where n is the number of elements in input array and k is the range of input. 
+
+**Space Complexity**: Algorithm takes extra space of O(k).
+
+<hr>
+
+## Important
+Counting sort is efficient if the range of input data is not significantly greater than the number of objects to be sorted. Consider the situation where the input sequence is between range 1 to 10K and the data is 10, 5, 10K, 5K. 
+
+<hr>
+
+Other Resources : [GFG Blog](https://www.geeksforgeeks.org/counting-sort/)