Merge branch 'master' into patch-1

sorting/BeadSort.cpp

@@ -0,0 +1,63 @@
+// C++ program to implement gravity/bead sort 
+#include <stdio.h>
+#include <string.h>
+using namespace std; 
+  
+#define BEAD(i, j) beads[i * max + j] 
+  
+// function to perform the above algorithm 
+void beadSort(int *a, int len) 
+{ 
+    // Find the maximum element 
+    int max = a[0]; 
+    for (int i = 1; i < len; i++) 
+        if (a[i] > max) 
+           max = a[i]; 
+  
+    // allocating memory 
+    unsigned char beads[max*len]; 
+    memset(beads, 0, sizeof(beads)); 
+  
+    // mark the beads 
+    for (int i = 0; i < len; i++) 
+        for (int j = 0; j < a[i]; j++) 
+            BEAD(i, j) = 1; 
+  
+    for (int j = 0; j < max; j++) 
+    { 
+        // count how many beads are on each post 
+        int sum = 0; 
+        for (int i=0; i < len; i++) 
+        { 
+            sum += BEAD(i, j); 
+            BEAD(i, j) = 0; 
+        } 
+  
+        // Move beads down 
+        for (int i = len - sum; i < len; i++) 
+            BEAD(i, j) = 1; 
+    } 
+  
+    // Put sorted values in array using beads 
+    for (int i = 0; i < len; i++) 
+    { 
+        int j; 
+        for (j = 0; j < max && BEAD(i, j); j++); 
+  
+        a[i] = j; 
+    } 
+} 
+  
+// driver function to test the algorithm 
+int main() 
+{ 
+    int a[] = {5, 3, 1, 7, 4, 1, 1, 20}; 
+    int len = sizeof(a)/sizeof(a[0]); 
+  
+    beadSort(a, len); 
+  
+    for (int i = 0; i < len; i++) 
+        printf("%d ", a[i]); 
+  
+    return 0; 
+} 

sorting/BitonicSort.cpp

@@ -0,0 +1,76 @@
+// Source : https://www.geeksforgeeks.org/bitonic-sort/
+
+/* C++ Program for Bitonic Sort. Note that this program 
+   works only when size of input is a power of 2. */
+
+#include <stdio.h>
+#include <algorithm.h>
+using namespace std;
+
+/*The parameter dir indicates the sorting direction, ASCENDING 
+   or DESCENDING; if (a[i] > a[j]) agrees with the direction, 
+   then a[i] and a[j] are interchanged.*/
+void compAndSwap(int a[], int i, int j, int dir)
+{
+    if (dir == (a[i] > a[j]))
+        swap(a[i], a[j]);
+}
+
+/*It recursively sorts a bitonic sequence in ascending order, 
+  if dir = 1, and in descending order otherwise (means dir=0). 
+  The sequence to be sorted starts at index position low, 
+  the parameter cnt is the number of elements to be sorted.*/
+void bitonicMerge(int a[], int low, int cnt, int dir)
+{
+    if (cnt > 1)
+    {
+        int k = cnt / 2;
+        for (int i = low; i < low + k; i++)
+            compAndSwap(a, i, i + k, dir);
+        bitonicMerge(a, low, k, dir);
+        bitonicMerge(a, low + k, k, dir);
+    }
+}
+
+/* This function first produces a bitonic sequence by recursively 
+    sorting its two halves in opposite sorting orders, and then 
+    calls bitonicMerge to make them in the same order */
+void bitonicSort(int a[], int low, int cnt, int dir)
+{
+    if (cnt > 1)
+    {
+        int k = cnt / 2;
+
+        // sort in ascending order since dir here is 1
+        bitonicSort(a, low, k, 1);
+
+        // sort in descending order since dir here is 0
+        bitonicSort(a, low + k, k, 0);
+
+        // Will merge wole sequence in ascending order
+        // since dir=1.
+        bitonicMerge(a, low, cnt, dir);
+    }
+}
+
+/* Caller of bitonicSort for sorting the entire array of 
+   length N in ASCENDING order */
+void sort(int a[], int N, int up)
+{
+    bitonicSort(a, 0, N, up);
+}
+
+// Driver code
+int main()
+{
+    int a[] = {3, 7, 4, 8, 6, 2, 1, 5};
+    int N = sizeof(a) / sizeof(a[0]);
+
+    int up = 1; // means sort in ascending order
+    sort(a, N, up);
+
+    printf("Sorted array: \n");
+    for (int i = 0; i < N; i++)
+        printf("%d ", a[i]);
+    return 0;
+}

sorting/Bubble Sort.cpp

@@ -1,53 +1,53 @@
 //Bubble Sort
 
-#include<iostream>
-#include<vector>
+
+#include <iostream>
+#include <vector>
+
 using namespace std;
 
 int main()
 {
 	int n;
-	short swap_check=0;
-  	cout << "Enter the amount of numbers to sort: ";
+	short swap_check = 1;
+	cout << "Enter the amount of numbers to sort: ";
 	cin >> n;
 	vector<int> numbers;
 	cout << "Enter " << n << " numbers: ";
 	int num;
 
-  	//Input
-	for(int i=0; i<n; i++)
+
+	//Input
+	for (int i = 0; i < n; i++)
 	{
 		cin >> num;
 		numbers.push_back(num);
 	}
 
 	//Bubble Sorting
-	for(int i=0; i<n; i++)
+
+	for (int i = 0; (i < n) && (swap_check == 1); i++)
 	{
-	    swap_check=0;
-		
-		for(int j=0; j<n-1-i; j++)
+		swap_check = 0;
+		for (int j = 0; j < n - 1 - i; j++)
 		{
-			if(numbers[j]>numbers[j+1])
+			if (numbers[j] > numbers[j + 1])
 			{
-				swap_check=1;
-				swap(numbers[j], numbers[j+1]);// by changing swap location. I mean, j. If the number is greater than j + 1, then it means the location.
+				swap_check = 1;
+				swap(numbers[j], numbers[j + 1]);// by changing swap location. I mean, j. If the number is greater than j + 1, then it means the location.
 			}
 		}
-		if(swap_check == 0)
-		{	
-			break;
-		}
 	}
 
 	//Output
-	cout<<"\nSorted Array : ";
-	for(int i=0; i<numbers.size(); i++)
+	cout << "\nSorted Array : ";
+	for (int i = 0; i < numbers.size(); i++)
 	{
-		if(i != numbers.size() -1)
+		if (i != numbers.size() - 1)
 		{
 			cout << numbers[i] << ", ";
-		}else
+		}
+		else
 		{
 			cout << numbers[i] << endl;
 		}

sorting/CocktailSelectionSort.cpp

@@ -0,0 +1,109 @@
+//Returns Sorted elements after performing Cocktail Selection Sort
+//It is a Sorting algorithm which chooses the minimum and maximum element in an array simultaneously,
+//and swaps it with the lowest and highest available position iteratively or recursively
+
+#include <iostream>
+using namespace std;
+
+//Iterative Version
+
+void CocktailSelectionSort(vector<int> &vec, int low, int high)
+{
+  while (low <= high)
+  {
+    int minimum = vec[low];
+    int minimumindex = low;
+    int maximum = vec[high];
+    int maximumindex = high;
+
+    for (int i = low; i <= high; i++)
+    {
+      if (vec[i] >= maximum)
+      {
+        maximum = vec[i];
+        maximumindex = i;
+      }
+      if (vec[i] <= minimum)
+      {
+        minimum = vec[i];
+        minimumindex = i;
+      }
+    }
+    if (low != maximumindex || high != minimumindex)
+    {
+      swap(vec[low], vec[minimumindex]);
+      swap(vec[high], vec[maximumindex]);
+    }
+    else
+    {
+      swap(vec[low], vec[high]);
+    }
+
+    low++;
+    high--;
+  }
+}
+
+//Recursive Version
+
+void CocktailSelectionSort(vector<int> &vec, int low, int high)
+{
+
+  if (low >= high)
+    return;
+
+  int minimum = vec[low];
+  int minimumindex = low;
+  int maximum = vec[high];
+  int maximumindex = high;
+
+  for (int i = low; i <= high; i++)
+  {
+    if (vec[i] >= maximum)
+    {
+      maximum = vec[i];
+      maximumindex = i;
+    }
+    if (vec[i] <= minimum)
+    {
+      minimum = vec[i];
+      minimumindex = i;
+    }
+  }
+  if (low != maximumindex || high != minimumindex)
+  {
+    swap(vec[low], vec[minimumindex]);
+    swap(vec[high], vec[maximumindex]);
+  }
+  else
+  {
+    swap(vec[low], vec[high]);
+  }
+
+  CocktailSelectionSort(vec, low + 1, high - 1);
+}
+
+//main function, select any one of iterative or recursive version
+
+int main()
+{
+
+  int n;
+  cout << "Enter number of elements\n";
+  cin >> n;
+  std::vector<int> v(n);
+  cout << "Enter all the elements\n";
+  for (int i = 0; i < n; ++i)
+  {
+    cin >> v[i];
+  }
+
+  CocktailSelectionSort(v, 0, n - 1);
+  cout << "Sorted elements are\n";
+  for (int i = 0; i < n; ++i)
+  {
+    cout << v[i] << " ";
+  }
+
+  return 0;
+}

sorting/CountingSortString.cpp

@@ -0,0 +1,41 @@
+// C++ Program for counting sort
+#include <iostream>
+
+using namespace std;
+
+void countSort(string arr)
+{
+
+    string output;
+
+    int count[256], i;
+    for (int i = 0; i < 256; i++)
+        count[i] = 0;
+
+    for (i = 0; arr[i]; ++i)
+        ++count[arr[i]];
+
+    for (i = 1; i <= 256; ++i)
+        count[i] += count[i - 1];
+
+    for (i = 0; arr[i]; ++i)
+    {
+        output[count[arr[i]] - 1] = arr[i];
+        --count[arr[i]];
+    }
+
+    for (i = 0; arr[i]; ++i)
+        arr[i] = output[i];
+
+    cout << "Sorted character array is " << arr;
+}
+
+int main()
+{
+    string arr;
+    cin >> arr;
+
+    countSort(arr);
+
+    return 0;
+}

sorting/Counting_Sort.cpp

@@ -0,0 +1,66 @@
+#include <iostream>
+using namespace std;
+
+int Max(int Arr[], int N)
+{
+	int max = Arr[0];
+	for (int i = 1; i < N; i++)
+		if (Arr[i] > max)
+			max = Arr[i];
+	return max;
+}
+
+int Min(int Arr[], int N)
+{
+	int min = Arr[0];
+	for (int i = 1; i < N; i++)
+		if (Arr[i] < min)
+			min = Arr[i];
+	return min;
+}
+
+void Print(int Arr[], int N)
+{
+	for (int i = 0; i < N; i++)
+		cout << Arr[i] << ", ";
+}
+
+int *Counting_Sort(int Arr[], int N)
+{
+
+	int max = Max(Arr, N);
+	int min = Min(Arr, N);
+	int *Sorted_Arr = new int[N];
+
+	int *Count = new int[max - min + 1];
+
+	for (int i = 0; i < N; i++)
+		Count[Arr[i] - min]++;
+
+	for (int i = 1; i < (max - min + 1); i++)
+		Count[i] += Count[i - 1];
+
+	for (int i = N - 1; i >= 0; i--)
+	{
+		Sorted_Arr[Count[Arr[i] - min] - 1] = Arr[i];
+		Count[Arr[i] - min]--;
+	}
+
+	return Sorted_Arr;
+}
+
+int main()
+{
+
+	int Arr[] = {47, 65, 20, 66, 25, 53, 64, 69, 72, 22, 74, 25, 53, 15, 42, 36, 4, 69, 86, 19}, N = 20;
+	int *Sorted_Arr;
+
+	cout << "\n\tOrignal Array = ";
+	Print(Arr, N);
+	Sorted_Arr = Counting_Sort(Arr, N);
+	cout << "\n\t Sorted Array = ";
+	Print(Sorted_Arr, N);
+	cout << endl;
+
+	return 0;
+}

sorting/Insertion Sort.cpp

@@ -0,0 +1,40 @@
+//Insertion Sort
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+	int n;
+	cout << "\nEnter the length of your array : ";
+	cin >> n;
+	int Array[n];
+	cout << "\nEnter any " << n << " Numbers for Unsorted Array : ";
+
+	//Input
+	for (int i = 0; i < n; i++)
+	{
+		cin >> Array[i];
+	}
+
+	//Sorting
+	for (int i = 1; i < n; i++)
+	{
+		int temp = Array[i];
+		int j = i - 1;
+		while (j >= 0 && temp < Array[j])
+		{
+			Array[j + 1] = Array[j];
+			j--;
+		}
+		Array[j + 1] = temp;
+	}
+
+	//Output
+	cout << "\nSorted Array : ";
+	for (int i = 0; i < n; i++)
+	{
+		cout << Array[i] << "\t";
+	}
+	return 0;
+}

sorting/Merge Sort.cpp

@@ -0,0 +1,93 @@
+#include <iostream>
+using namespace std;
+
+void merge(int arr[], int l, int m, int r)
+{
+    int i, j, k;
+    int n1 = m - l + 1;
+    int n2 = r - m;
+
+    int L[n1], R[n2];
+
+    for (i = 0; i < n1; i++)
+        L[i] = arr[l + i];
+    for (j = 0; j < n2; j++)
+        R[j] = arr[m + 1 + j];
+
+    i = 0;
+    j = 0;
+    k = l;
+    while (i < n1 && j < n2)
+    {
+        if (L[i] <= R[j])
+        {
+            arr[k] = L[i];
+            i++;
+        }
+        else
+        {
+            arr[k] = R[j];
+            j++;
+        }
+        k++;
+    }
+
+    while (i < n1)
+    {
+        arr[k] = L[i];
+        i++;
+        k++;
+    }
+
+    while (j < n2)
+    {
+        arr[k] = R[j];
+        j++;
+        k++;
+    }
+}
+
+void mergeSort(int arr[], int l, int r)
+{
+    if (l < r)
+    {
+
+        int m = l + (r - l) / 2;
+
+        mergeSort(arr, l, m);
+        mergeSort(arr, m + 1, r);
+
+        merge(arr, l, m, r);
+    }
+}
+
+void show(int A[], int size)
+{
+    int i;
+    for (i = 0; i < size; i++)
+        cout << A[i] << "\n";
+}
+
+int main()
+{
+    int size;
+    cout << "\nEnter the number of elements : ";
+
+    cin >> size;
+
+    int arr[size];
+
+    cout << "\nEnter the unsorted elements : ";
+
+    for (int i = 0; i < size; ++i)
+    {
+        cout << "\n";
+        cin >> arr[i];
+    }
+
+    mergeSort(arr, 0, size);
+
+    cout << "Sorted array\n";
+    show(arr, size);
+    return 0;
+}

sorting/NumericStringSort.cpp

@@ -0,0 +1,62 @@
+//Using general algorithms to sort a collection of strings results in alphanumeric sort.
+//If it is a numeric string, it leads to unnatural sorting
+
+//eg, an array of strings 1,10,100,2,20,200,3,30,300
+//would be sorted in that same order by using conventional sorting,
+//even though we know the correct sorting order is 1,2,3,10,20,30,100,200,300
+
+//This Programme uses a comparator to sort the array in Numerical order instead of Alphanumeric order
+
+#include <iostream>
+#include <string>
+#include <algorithm>
+using namespace std;
+
+bool NumericSort(string a, string b)
+{
+  while (a[0] == '0')
+  {
+    a.erase(a.begin());
+  }
+  while (b[0] == '0')
+  {
+    b.erase(b.begin());
+  }
+  int n = a.length();
+  int m = b.length();
+  if (n == m)
+    return a < b;
+  return n < m;
+}
+
+int main()
+{
+
+  int n;
+  cout << "Enter number of elements to be sorted Numerically\n";
+  cin >> n;
+
+  vector<string> v(n);
+  cout << "Enter the string of Numbers\n";
+  for (int i = 0; i < n; i++)
+  {
+    cin >> v[i];
+  }
+
+  sort(v.begin(), v.end());
+  cout << "Elements sorted normally \n";
+  for (int i = 0; i < n; i++)
+  {
+    cout << v[i] << " ";
+  }
+  cout << "\n";
+
+  sort(v.begin(), v.end(), NumericSort);
+  cout << "Elements sorted Numerically \n";
+  for (int i = 0; i < n; i++)
+  {
+    cout << v[i] << " ";
+  }
+
+  return 0;
+}

sorting/OddEven Sort.cpp

@@ -0,0 +1,61 @@
+/* C++ implementation Odd Even Sort */
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void oddEven(vector<int> &arr, int size)
+{
+	bool sorted = false;
+	while (!sorted)
+	{
+		sorted = true;
+		for (int i = 1; i < size - 1; i += 2) //Odd
+		{
+			if (arr[i] > arr[i + 1])
+			{
+				swap(arr[i], arr[i + 1]);
+				sorted = false;
+			}
+		}
+
+		for (int i = 0; i < size - 1; i += 2) //Even
+		{
+			if (arr[i] > arr[i + 1])
+			{
+				swap(arr[i], arr[i + 1]);
+				sorted = false;
+			}
+		}
+	}
+}
+
+void show(vector<int> A, int size)
+{
+	int i;
+	for (i = 0; i < size; i++)
+		cout << A[i] << "\n";
+}
+
+int main()
+{
+	int size, temp;
+	cout << "\nEnter the number of elements : ";
+	cin >> size;
+
+	vector<int> arr;
+
+	cout << "\nEnter the unsorted elements : \n";
+
+	for (int i = 0; i < size; ++i)
+	{
+		cin >> temp;
+		arr.push_back(temp);
+	}
+
+	oddEven(arr, size);
+
+	cout << "Sorted array\n";
+	show(arr, size);
+	return 0;
+}

sorting/Quick Sort.cpp

@@ -0,0 +1,67 @@
+/* C implementation QuickSort */
+#include <iostream>
+using namespace std;
+
+int partition(int arr[], int low, int high)
+{
+    int pivot = arr[high]; // pivot
+    int i = (low - 1);     // Index of smaller element
+
+    for (int j = low; j < high; j++)
+    {
+        // If current element is smaller than or
+        // equal to pivot
+        if (arr[j] <= pivot)
+        {
+            i++; // increment index of smaller element
+            int temp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = temp;
+        }
+    }
+    int temp = arr[i + 1];
+    arr[i + 1] = arr[high];
+    arr[high] = temp;
+    return (i + 1);
+}
+
+void quickSort(int arr[], int low, int high)
+{
+    if (low < high)
+    {
+
+        int p = partition(arr, low, high);
+
+        quickSort(arr, low, p - 1);
+        quickSort(arr, p + 1, high);
+    }
+}
+
+void show(int arr[], int size)
+{
+    for (int i = 0; i < size; i++)
+        cout << arr[i] << "\n";
+}
+
+// Driver program to test above functions
+int main()
+{
+    int size;
+    cout << "\nEnter the number of elements : ";
+
+    cin >> size;
+
+    int arr[size];
+
+    cout << "\nEnter the unsorted elements : ";
+
+    for (int i = 0; i < size; ++i)
+    {
+        cout << "\n";
+        cin >> arr[i];
+    }
+    quickSort(arr, 0, size);
+    cout << "Sorted array\n";
+    show(arr, size);
+    return 0;
+}

sorting/Radix Sort.cpp

@@ -0,0 +1,68 @@
+#include <iostream>
+#include <cstdlib>
+#include <cmath>
+#include <cstring>
+using namespace std;
+void radixsort(int a[], int n)
+{
+	int count[10];
+	int output[n];
+	memset(output, 0, sizeof(output));
+	memset(count, 0, sizeof(count));
+	int max = 0;
+	for (int i = 0; i < n; ++i)
+	{
+		if (a[i] > max)
+		{
+			max = a[i];
+		}
+	}
+	int maxdigits = 0;
+	while (max)
+	{
+		maxdigits++;
+		max /= 10;
+	}
+	for (int j = 0; j < maxdigits; j++)
+	{
+		for (int i = 0; i < n; i++)
+		{
+			int t = pow(10, j);
+			count[(a[i] % (10 * t)) / t]++;
+		}
+		int k = 0;
+		for (int p = 0; p < 10; p++)
+		{
+			for (int i = 0; i < n; i++)
+			{
+				int t = pow(10, j);
+				if ((a[i] % (10 * t)) / t == p)
+				{
+					output[k] = a[i];
+					k++;
+				}
+			}
+		}
+		memset(count, 0, sizeof(count));
+		for (int i = 0; i < n; ++i)
+		{
+			a[i] = output[i];
+		}
+	}
+}
+void print(int a[], int n)
+{
+	for (int i = 0; i < n; ++i)
+	{
+		cout << a[i] << " ";
+	}
+	cout << endl;
+}
+int main(int argc, char const *argv[])
+{
+	int a[] = {170, 45, 75, 90, 802, 24, 2, 66};
+	int n = sizeof(a) / sizeof(a[0]);
+	radixsort(a, n);
+	print(a, n);
+	return 0;
+}

sorting/Selection Sort.cpp

@@ -0,0 +1,39 @@
+//Selection Sort
+
+#include <iostream>
+using namespace std;
+
+int main()
+{
+	int Array[6];
+	cout << "\nEnter any 6 Numbers for Unsorted Array : ";
+
+	//Input
+	for (int i = 0; i < 6; i++)
+	{
+		cin >> Array[i];
+	}
+
+	//Selection Sorting
+	for (int i = 0; i < 6; i++)
+	{
+		int min = i;
+		for (int j = i + 1; j < 6; j++)
+		{
+			if (Array[j] < Array[min])
+			{
+				min = j; //Finding the smallest number in Array
+			}
+		}
+		int temp = Array[i];
+		Array[i] = Array[min];
+		Array[min] = temp;
+	}
+
+	//Output
+	cout << "\nSorted Array : ";
+	for (int i = 0; i < 6; i++)
+	{
+		cout << Array[i] << "\t";
+	}
+}

sorting/Shell Sort.cpp

@@ -0,0 +1,45 @@
+#include <iostream>
+using namespace std;
+
+int main()
+{
+	int size = 10;
+	int array[size];
+	// Input
+	cout << "\nHow many numbers do want to enter in unsorted array : ";
+	cin >> size;
+	cout << "\nEnter the numbers for unsorted array : ";
+	for (int i = 0; i < size; i++)
+	{
+		cin >> array[i];
+	}
+
+	// Sorting
+	for (int i = size / 2; i > 0; i = i / 2)
+	{
+		for (int j = i; j < size; j++)
+		{
+			for (int k = j - i; k >= 0; k = k - i)
+			{
+				if (array[k] < array[k + i])
+				{
+					break;
+				}
+				else
+				{
+					int temp = array[k + i];
+					array[k + i] = array[k];
+					array[k] = temp;
+				}
+			}
+		}
+	}
+
+	// Output
+	cout << "\nSorted array : ";
+	for (int i = 0; i < size; ++i)
+	{
+		cout << array[i] << "\t";
+	}
+	return 0;
+}

sorting/Slow Sort.cpp

@@ -0,0 +1,57 @@
+//Returns the sorted vector after performing SlowSort
+//It is a sorting algorithm that is of humorous nature and not useful.
+//It's based on the principle of multiply and surrender, a tongue-in-cheek joke of divide and conquer.
+//It was published in 1986 by Andrei Broder and Jorge Stolfi in their paper Pessimal Algorithms and Simplexity Analysis.
+//This algorithm multiplies a single problem into multiple subproblems
+//It is interesting because it is provably the least efficient sorting algorithm that can be built asymptotically,
+//and with the restriction that such an algorithm, while being slow, must still all the time be working towards a result.
+
+#include <iostream>
+using namespace std;
+
+void SlowSort(int a[], int i, int j)
+{
+  if (i >= j)
+    return;
+  int m = i + (j - i) / 2; //midpoint, implemented this way to avoid overflow
+  int temp;
+  SlowSort(a, i, m);
+  SlowSort(a, m + 1, j);
+  if (a[j] < a[m])
+  {
+    temp = a[j]; //swapping a[j] & a[m]
+    a[j] = a[m];
+    a[m] = temp;
+  }
+  SlowSort(a, i, j - 1);
+}
+
+//Sample Main function
+
+int main()
+{
+  int size;
+  cout << "\nEnter the number of elements : ";
+
+  cin >> size;
+
+  int arr[size];
+
+  cout << "\nEnter the unsorted elements : ";
+
+  for (int i = 0; i < size; ++i)
+  {
+    cout << "\n";
+    cin >> arr[i];
+  }
+
+  SlowSort(arr, 0, size);
+
+  cout << "Sorted array\n";
+
+  for (int i = 0; i < size; ++i)
+  {
+    cout << arr[i] << " ";
+  }
+  return 0;
+}

sorting/Tim Sort.cpp

@@ -0,0 +1,116 @@
+// C++ program to perform TimSort.
+#include <iostream>
+using namespace std;
+const int RUN = 32;
+ 
+// this function sorts array from left index to to right index which is of size atmost RUN
+void insertionSort(int arr[], int left, int right)
+{
+    for (int i = left + 1; i <= right; i++)
+    {
+        int temp = arr[i];
+        int j = i - 1;
+        while (arr[j] > temp && j >= left)
+        {
+            arr[j+1] = arr[j];
+            j--;
+        }
+        arr[j+1] = temp;
+    }
+}
+ 
+// merge function merges the sorted runs
+void merge(int arr[], int l, int m, int r)
+{
+    // original array is broken in two parts, left and right array
+    int len1 = m - l + 1, len2 = r - m;
+    int left[len1], right[len2];
+    for (int i = 0; i < len1; i++)
+        left[i] = arr[l + i];
+    for (int i = 0; i < len2; i++)
+        right[i] = arr[m + 1 + i];
+ 
+    int i = 0;
+    int j = 0;
+    int k = l;
+ 
+    // after comparing, we merge those two array in larger sub array
+    while (i < len1 && j < len2)
+    {
+        if (left[i] <= right[j])
+        {
+            arr[k] = left[i];
+            i++;
+        }
+        else
+        {
+            arr[k] = right[j];
+            j++;
+        }
+        k++;
+    }
+ 
+    // copy remaining elements of left, if any
+    while (i < len1)
+    {
+        arr[k] = left[i];
+        k++;
+        i++;
+    }
+ 
+    // copy remaining element of right, if any
+    while (j < len2)
+    {
+        arr[k] = right[j];
+        k++;
+        j++;
+    }
+}
+ 
+// iterative Timsort function to sort the array[0...n-1] (similar to merge sort)
+void timSort(int arr[], int n)
+{
+    // Sort individual subarrays of size RUN
+    for (int i = 0; i < n; i+=RUN)
+        insertionSort(arr, i, min((i+31), (n-1)));
+ 
+    // start merging from size RUN (or 32). It will merge to form size 64, then 128, 256 and so on ....
+    for (int size = RUN; size < n; size = 2*size)
+    {
+        // pick starting point of left sub array. We are going to merge arr[left..left+size-1] and arr[left+size, left+2*size-1]
+        // After every merge, we increase left by 2*size
+        for (int left = 0; left < n; left += 2*size)
+        {
+            // find ending point of left sub array
+            // mid+1 is starting point of right sub array
+            int mid = left + size - 1;
+            int right = min((left + 2*size - 1), (n-1));
+ 
+            // merge sub array arr[left.....mid] & arr[mid+1....right]
+            merge(arr, left, mid, right);
+        }
+    }
+}
+ 
+// utility function to print the Array
+void printArray(int arr[], int n)
+{
+    for (int i = 0; i < n; i++)
+        printf("%d  ", arr[i]);
+    printf("\n");
+}
+ 
+// Driver program to test above function
+int main()
+{
+    int arr[] = {5, 21, 7, 23, 19};
+    int n = sizeof(arr)/sizeof(arr[0]);
+    printf("Given Array is\n");
+    printArray(arr, n);
+ 
+    timSort(arr, n);
+ 
+    printf("After Sorting Array is\n");
+    printArray(arr, n);
+    return 0;
+}

sorting/bucketSort.cpp

@@ -0,0 +1,42 @@
+// C++ program to sort an array using bucket sort
+#include <iostream>
+#include <algorithm>
+#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 funtion */
+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;
+}

sorting/combsort.cpp

@@ -0,0 +1,59 @@
+//Kind of better version of Bubble sort.
+//While Bubble sort is comparering adjacent value, Combsort is using gap larger than 1
+//Best case: O(n)
+//Worst case: O(n ^ 2)
+
+#include <iostream>
+
+using namespace std;
+
+int a[100005];
+int n;
+
+int FindNextGap(int x)
+{
+    x = (x * 10) / 13;
+
+    return max(1, x);
+}
+
+void CombSort(int a[], int l, int r)
+{
+    //Init gap
+    int gap = n;
+
+    //Initialize swapped as true to make sure that loop runs
+    bool swapped = true;
+
+    //Keep running until gap = 1 or none elements were swapped
+    while (gap != 1 || swapped)
+    {
+        //Find next gap
+        gap = FindNextGap(gap);
+
+        swapped = false;
+
+        // Compare all elements with current gap
+        for (int i = l; i <= r - gap; ++i)
+        {
+            if (a[i] > a[i + gap])
+            {
+                swap(a[i], a[i + gap]);
+                swapped = true;
+            }
+        }
+    }
+}
+
+int main()
+{
+    cin >> n;
+    for (int i = 1; i <= n; ++i)
+        cin >> a[i];
+
+    CombSort(a, 1, n);
+
+    for (int i = 1; i <= n; ++i)
+        cout << a[i] << ' ';
+    return 0;
+}

sorting/heap_sort.cpp

@@ -0,0 +1,52 @@
+#include <algorithm>
+#include <iostream>
+
+void heapify(int *a, int i, int n) {
+    int largest = i;
+    const int l = 2 * i + 1;
+    const int r = 2 * i + 2;
+
+    if (l < n && a[l] > a[largest])
+        largest = l;
+
+    if (r < n && a[r] > a[largest])
+        largest = r;
+
+    if (largest != i) {
+        std::swap(a[i], a[largest]);
+        heapify(a, n, largest);
+    }
+}
+
+void heapsort(int *a, int n) {
+    for (int i = n - 1; i >= 0; --i) {
+        std::swap(a[0], a[i]);
+        heapify(a, 0, i);
+    }
+}
+
+void build_maxheap(int *a, int n) {
+    for (int i = n / 2 - 1; i >= 0; --i) {
+        heapify(a, i, n);
+    }
+}
+
+int main() {
+    int n;
+    std::cout << "Enter number of elements of array\n";
+    std::cin >> n;
+    int a[20];
+    for (int i = 0; i < n; ++i) {
+        std::cout << "Enter Element " << i << std::endl;
+        std::cin >> a[i];
+    }
+
+    build_maxheap(a, n);
+    heapsort(a, n);
+    std::cout << "Sorted Output\n";
+    for (int i = 0; i < n; ++i) {
+        std::cout << a[i] << std::endl;
+    }
+
+    std::getchar();
+}

sorting/library_sort.cpp

@@ -0,0 +1,90 @@
+#include <algorithm>
+#include <iostream>
+
+void librarySort(int *index, int n) {
+    int lib_size, index_pos,
+        *gaps,        // gaps
+        *library[2];  // libraries
+
+    bool target_lib, *numbered;
+
+    for (int i = 0; i < 2; i++)
+        library[i] = new int[n];
+
+    gaps = new int[n + 1];
+    numbered = new bool[n + 1];
+
+    lib_size = 1;
+    index_pos = 1;
+    target_lib = 0;
+    library[target_lib][0] = index[0];
+
+    while (index_pos < n) {
+        // binary search
+        int insert = std::distance(
+            library[target_lib],
+            std::lower_bound(library[target_lib],
+                             library[target_lib] + lib_size, index[index_pos]));
+
+        // if there is no gap to insert a new index ...
+
+        if (numbered[insert] == true) {
+            int prov_size = 0, next_target_lib = !target_lib;
+
+            // update library and clear gaps
+
+            for (int i = 0; i <= n; i++) {
+                if (numbered[i] == true) {
+                    library[next_target_lib][prov_size] = gaps[i];
+                    prov_size++;
+                    numbered[i] = false;
+                }
+
+                if (i <= lib_size) {
+                    library[next_target_lib][prov_size] =
+                        library[target_lib][i];
+                    prov_size++;
+                }
+            }
+
+            target_lib = next_target_lib;
+            lib_size = prov_size - 1;
+        } else {
+            numbered[insert] = true;
+            gaps[insert] = index[index_pos];
+            index_pos++;
+        }
+    }
+
+    int index_pos_for_output = 0;
+    for (int i = 0; index_pos_for_output < n; i++) {
+        if (numbered[i] == true) {
+            // std::cout << gaps[i] << std::endl;
+            index[index_pos_for_output] = gaps[i];
+            index_pos_for_output++;
+        }
+
+        if (i < lib_size) {
+            // std::cout << library[target_lib][i] << std::endl;
+            index[index_pos_for_output] = library[target_lib][i];
+            index_pos_for_output++;
+        }
+    }
+}
+
+int main() {
+    // ---example--
+    int index_ex[] = {-6, 5, 9, 1, 9, 1, 0, 1, -8, 4, -12};
+    int n_ex = sizeof(index_ex) / sizeof(index_ex[0]);
+
+    librarySort(index_ex, n_ex);
+    std::cout << "sorted array :" << std::endl;
+    for (int i = 0; i < n_ex; i++)
+        std::cout << index_ex[i] << " ";
+    std::cout << std::endl;
+
+    /* --output--
+    sorted array :
+    -12 -8 -6 0 1 1 1 4 5 9 9
+    */
+}