deploy: 57ea7b1f9d

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; 
+} 

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;
+}

Bubble Sort.cpp

@@ -0,0 +1,83 @@
+//Bubble Sort
+
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int main()
+{
+	int n;
+	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++)
+	{
+		cin >> num;
+		numbers.push_back(num);
+	}
+
+	//Bubble Sorting
+	for (int i = 0; (i < n) && (swap_check == 1); i++)
+	{
+		swap_check = 0;
+		for (int j = 0; j < n - 1 - i; j++)
+		{
+			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.
+			}
+		}
+	}
+
+	//Output
+	cout << "\nSorted Array : ";
+	for (int i = 0; i < numbers.size(); i++)
+	{
+		if (i != numbers.size() - 1)
+		{
+			cout << numbers[i] << ", ";
+		}
+		else
+		{
+			cout << numbers[i] << endl;
+		}
+	}
+	return 0;
+}
+
+/*The working principle of the Bubble sort algorithm:
+
+Bubble sort algorithm is the bubble sorting algorithm. The most important reason for calling the bubble is that the largest number is thrown at the end of this algorithm.
+This is all about the logic.
+In each iteration, the largest number is expired and when iterations are completed, the sorting takes place.
+
+What is Swap?
+
+Swap in the software means that two variables are displaced.
+An additional variable is required for this operation. x = 5, y = 10.
+We want x = 10, y = 5. Here we create the most variable to do it.
+
+int z;
+z = x;
+x = y;
+y = z;
+
+The above process is a typical displacement process.
+When x assigns the value to x, the old value of x is lost.
+That's why we created a variable z to create the first value of the value of x, and finally, we have assigned to y.
+
+Bubble Sort Algorithm Analysis (Best Case - Worst Case - Average Case)
+
+Bubble Sort Worst Case Performance is O (n²). Why is that? Because if you remember Big O Notation, we were calculating the complexity of the algorithms in the nested loops.
+The n * (n - 1) product gives us O (n²) performance. In the worst case all the steps of the cycle will occur.
+Bubble Sort (Avarage Case) Performance. Bubble Sort is not an optimal algorithm.
+in average, O (n²) performance is taken.
+Bubble Sort Best Case Performance. O (n).
+However, you can't get the best status in the code we shared above. This happens on the optimized bubble sort algorithm. It's right down there.
+* /

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;
+}

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;
+}

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;
+}

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;
+}

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;
+}

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;
+}

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;
+}

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;
+}

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;
+}

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";
+	}
+}

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;
+}

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;
+}

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;
+}

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;
+}

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;
+}

doxy.txt

@@ -0,0 +1,374 @@
+# Doxyfile 1.8.13
+#This configuration file has been generated from Doxygen template.
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+DOXYFILE_ENCODING      = UTF-8
+PROJECT_NAME           = "My Project"
+PROJECT_NUMBER         =
+PROJECT_BRIEF          =
+PROJECT_LOGO           =
+OUTPUT_DIRECTORY       =
+CREATE_SUBDIRS         = NO
+ALLOW_UNICODE_NAMES    = NO
+OUTPUT_LANGUAGE        = English
+BRIEF_MEMBER_DESC      = YES
+REPEAT_BRIEF           = YES
+ABBREVIATE_BRIEF       = "The $name class" \
+                         "The $name widget" \
+                         "The $name file" \
+                         is \
+                         provides \
+                         specifies \
+                         contains \
+                         represents \
+                         a \
+                         an \
+                         the
+ALWAYS_DETAILED_SEC    = NO
+INLINE_INHERITED_MEMB  = NO
+FULL_PATH_NAMES        = YES
+STRIP_FROM_PATH        =
+STRIP_FROM_INC_PATH    =
+SHORT_NAMES            = NO
+JAVADOC_AUTOBRIEF      = NO
+QT_AUTOBRIEF           = NO
+MULTILINE_CPP_IS_BRIEF = NO
+INHERIT_DOCS           = YES
+SEPARATE_MEMBER_PAGES  = NO
+TAB_SIZE               = 4
+ALIASES                =
+TCL_SUBST              =
+OPTIMIZE_OUTPUT_FOR_C  = NO
+OPTIMIZE_OUTPUT_JAVA   = NO
+OPTIMIZE_FOR_FORTRAN   = NO
+OPTIMIZE_OUTPUT_VHDL   = NO
+EXTENSION_MAPPING      =
+MARKDOWN_SUPPORT       = YES
+TOC_INCLUDE_HEADINGS   = 0
+AUTOLINK_SUPPORT       = YES
+BUILTIN_STL_SUPPORT    = NO
+CPP_CLI_SUPPORT        = NO
+SIP_SUPPORT            = NO
+IDL_PROPERTY_SUPPORT   = YES
+DISTRIBUTE_GROUP_DOC   = NO
+GROUP_NESTED_COMPOUNDS = NO
+SUBGROUPING            = YES
+INLINE_GROUPED_CLASSES = NO
+INLINE_SIMPLE_STRUCTS  = NO
+TYPEDEF_HIDES_STRUCT   = NO
+LOOKUP_CACHE_SIZE      = 0
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL            = NO
+EXTRACT_PRIVATE        = NO
+EXTRACT_PACKAGE        = NO
+EXTRACT_STATIC         = NO
+EXTRACT_LOCAL_CLASSES  = YES
+EXTRACT_LOCAL_METHODS  = NO
+EXTRACT_ANON_NSPACES   = NO
+HIDE_UNDOC_MEMBERS     = NO
+HIDE_UNDOC_CLASSES     = NO
+HIDE_FRIEND_COMPOUNDS  = NO
+HIDE_IN_BODY_DOCS      = NO
+INTERNAL_DOCS          = NO
+CASE_SENSE_NAMES       = YES
+HIDE_SCOPE_NAMES       = NO
+HIDE_COMPOUND_REFERENCE= NO
+SHOW_INCLUDE_FILES     = YES
+SHOW_GROUPED_MEMB_INC  = NO
+FORCE_LOCAL_INCLUDES   = NO
+INLINE_INFO            = YES
+SORT_MEMBER_DOCS       = YES
+SORT_BRIEF_DOCS        = NO
+SORT_MEMBERS_CTORS_1ST = NO
+SORT_GROUP_NAMES       = NO
+SORT_BY_SCOPE_NAME     = NO
+STRICT_PROTO_MATCHING  = NO
+GENERATE_TODOLIST      = YES
+GENERATE_TESTLIST      = YES
+GENERATE_BUGLIST       = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS       =
+MAX_INITIALIZER_LINES  = 30
+SHOW_USED_FILES        = YES
+SHOW_FILES             = YES
+SHOW_NAMESPACES        = YES
+FILE_VERSION_FILTER    =
+LAYOUT_FILE            =
+CITE_BIB_FILES         =
+#---------------------------------------------------------------------------
+# Configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET                  = NO
+WARNINGS               = YES
+WARN_IF_UNDOCUMENTED   = YES
+WARN_IF_DOC_ERROR      = YES
+WARN_NO_PARAMDOC       = NO
+WARN_AS_ERROR          = NO
+WARN_FORMAT            = "$file:$line: $text"
+WARN_LOGFILE           =
+#---------------------------------------------------------------------------
+# Configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT                  =
+INPUT_ENCODING         = UTF-8
+FILE_PATTERNS          = *.c \
+                         *.cc \
+                         *.cxx \
+                         *.cpp \
+                         *.c++ \
+                         *.java \
+                         *.ii \
+                         *.ixx \
+                         *.ipp \
+                         *.i++ \
+                         *.inl \
+                         *.idl \
+                         *.ddl \
+                         *.odl \
+                         *.h \
+                         *.hh \
+                         *.hxx \
+                         *.hpp \
+                         *.h++ \
+                         *.cs \
+                         *.d \
+                         *.php \
+                         *.php4 \
+                         *.php5 \
+                         *.phtml \
+                         *.inc \
+                         *.m \
+                         *.markdown \
+                         *.md \
+                         *.mm \
+                         *.dox \
+                         *.py \
+                         *.pyw \
+                         *.f90 \
+                         *.f95 \
+                         *.f03 \
+                         *.f08 \
+                         *.f \
+                         *.for \
+                         *.tcl \
+                         *.vhd \
+                         *.vhdl \
+                         *.ucf \
+                         *.qsf
+RECURSIVE              = NO
+EXCLUDE                =
+EXCLUDE_SYMLINKS       = NO
+EXCLUDE_PATTERNS       =
+EXCLUDE_SYMBOLS        =
+EXAMPLE_PATH           =
+EXAMPLE_PATTERNS       = *
+EXAMPLE_RECURSIVE      = NO
+IMAGE_PATH             =
+INPUT_FILTER           =
+FILTER_PATTERNS        =
+FILTER_SOURCE_FILES    = NO
+FILTER_SOURCE_PATTERNS =
+USE_MDFILE_AS_MAINPAGE =
+#---------------------------------------------------------------------------
+# Configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER         = NO
+INLINE_SOURCES         = NO
+STRIP_CODE_COMMENTS    = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION    = NO
+REFERENCES_LINK_SOURCE = YES
+SOURCE_TOOLTIPS        = YES
+USE_HTAGS              = NO
+VERBATIM_HEADERS       = YES
+CLANG_ASSISTED_PARSING = NO
+CLANG_OPTIONS          =
+#---------------------------------------------------------------------------
+# Configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX     = YES
+COLS_IN_ALPHA_INDEX    = 5
+IGNORE_PREFIX          =
+#---------------------------------------------------------------------------
+# Configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML          = YES
+HTML_OUTPUT            = html
+HTML_FILE_EXTENSION    = .html
+HTML_HEADER            =
+HTML_FOOTER            =
+HTML_STYLESHEET        =
+HTML_EXTRA_STYLESHEET  =
+HTML_EXTRA_FILES       =
+HTML_COLORSTYLE_HUE    = 220
+HTML_COLORSTYLE_SAT    = 100
+HTML_COLORSTYLE_GAMMA  = 80
+HTML_TIMESTAMP         = NO
+HTML_DYNAMIC_SECTIONS  = NO
+HTML_INDEX_NUM_ENTRIES = 100
+GENERATE_DOCSET        = NO
+DOCSET_FEEDNAME        = "Doxygen generated docs"
+DOCSET_BUNDLE_ID       = org.doxygen.Project
+DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
+DOCSET_PUBLISHER_NAME  = Publisher
+GENERATE_HTMLHELP      = NO
+CHM_FILE               =
+HHC_LOCATION           =
+GENERATE_CHI           = NO
+CHM_INDEX_ENCODING     =
+BINARY_TOC             = NO
+TOC_EXPAND             = NO
+GENERATE_QHP           = NO
+QCH_FILE               =
+QHP_NAMESPACE          = org.doxygen.Project
+QHP_VIRTUAL_FOLDER     = doc
+QHP_CUST_FILTER_NAME   =
+QHP_CUST_FILTER_ATTRS  =
+QHP_SECT_FILTER_ATTRS  =
+QHG_LOCATION           =
+GENERATE_ECLIPSEHELP   = NO
+ECLIPSE_DOC_ID         = org.doxygen.Project
+DISABLE_INDEX          = NO
+GENERATE_TREEVIEW      = NO
+ENUM_VALUES_PER_LINE   = 4
+TREEVIEW_WIDTH         = 250
+EXT_LINKS_IN_WINDOW    = NO
+FORMULA_FONTSIZE       = 10
+FORMULA_TRANSPARENT    = YES
+USE_MATHJAX            = NO
+MATHJAX_FORMAT         = HTML-CSS
+MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_EXTENSIONS     =
+MATHJAX_CODEFILE       =
+SEARCHENGINE           = YES
+SERVER_BASED_SEARCH    = NO
+EXTERNAL_SEARCH        = NO
+SEARCHENGINE_URL       =
+SEARCHDATA_FILE        = searchdata.xml
+EXTERNAL_SEARCH_ID     =
+EXTRA_SEARCH_MAPPINGS  =
+#---------------------------------------------------------------------------
+# Configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX         = NO
+LATEX_OUTPUT           = latex
+LATEX_CMD_NAME         = latex
+MAKEINDEX_CMD_NAME     = makeindex
+COMPACT_LATEX          = NO
+PAPER_TYPE             = a4
+EXTRA_PACKAGES         =
+LATEX_HEADER           =
+LATEX_FOOTER           =
+LATEX_EXTRA_STYLESHEET =
+LATEX_EXTRA_FILES      =
+PDF_HYPERLINKS         = YES
+USE_PDFLATEX           = YES
+LATEX_BATCHMODE        = NO
+LATEX_HIDE_INDICES     = NO
+LATEX_SOURCE_CODE      = NO
+LATEX_BIB_STYLE        = plain
+LATEX_TIMESTAMP        = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF           = NO
+RTF_OUTPUT             = rtf
+COMPACT_RTF            = NO
+RTF_HYPERLINKS         = NO
+RTF_STYLESHEET_FILE    =
+RTF_EXTENSIONS_FILE    =
+RTF_SOURCE_CODE        = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN           = NO
+MAN_OUTPUT             = man
+MAN_EXTENSION          = .3
+MAN_SUBDIR             =
+MAN_LINKS              = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML           = NO
+XML_OUTPUT             = xml
+XML_PROGRAMLISTING     = YES
+#---------------------------------------------------------------------------
+# Configuration options related to the DOCBOOK output
+#---------------------------------------------------------------------------
+GENERATE_DOCBOOK       = NO
+DOCBOOK_OUTPUT         = docbook
+DOCBOOK_PROGRAMLISTING = NO
+#---------------------------------------------------------------------------
+# Configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF   = NO
+#---------------------------------------------------------------------------
+# Configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD       = NO
+PERLMOD_LATEX          = NO
+PERLMOD_PRETTY         = YES
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING   = YES
+MACRO_EXPANSION        = NO
+EXPAND_ONLY_PREDEF     = NO
+SEARCH_INCLUDES        = YES
+INCLUDE_PATH           =
+INCLUDE_FILE_PATTERNS  =
+PREDEFINED             =
+EXPAND_AS_DEFINED      =
+SKIP_FUNCTION_MACROS   = YES
+#---------------------------------------------------------------------------
+# Configuration options related to external references
+#---------------------------------------------------------------------------
+TAGFILES               =
+GENERATE_TAGFILE       =
+ALLEXTERNALS           = NO
+EXTERNAL_GROUPS        = YES
+EXTERNAL_PAGES         = YES
+PERL_PATH              = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS         = YES
+MSCGEN_PATH            =
+DIA_PATH               =
+HIDE_UNDOC_RELATIONS   = YES
+HAVE_DOT               = YES
+DOT_NUM_THREADS        = 0
+DOT_FONTNAME           = Helvetica
+DOT_FONTSIZE           = 10
+DOT_FONTPATH           =
+CLASS_GRAPH            = YES
+COLLABORATION_GRAPH    = YES
+GROUP_GRAPHS           = YES
+UML_LOOK               = NO
+UML_LIMIT_NUM_FIELDS   = 10
+TEMPLATE_RELATIONS     = NO
+INCLUDE_GRAPH          = YES
+INCLUDED_BY_GRAPH      = YES
+CALL_GRAPH             = NO
+CALLER_GRAPH           = NO
+GRAPHICAL_HIERARCHY    = YES
+DIRECTORY_GRAPH        = YES
+DOT_IMAGE_FORMAT       = png
+INTERACTIVE_SVG        = NO
+DOT_PATH               =
+DOTFILE_DIRS           =
+MSCFILE_DIRS           =
+DIAFILE_DIRS           =
+PLANTUML_JAR_PATH      =
+PLANTUML_CFG_FILE      =
+PLANTUML_INCLUDE_PATH  =
+DOT_GRAPH_MAX_NODES    = 50
+MAX_DOT_GRAPH_DEPTH    = 0
+DOT_TRANSPARENT        = NO
+DOT_MULTI_TARGETS      = NO
+GENERATE_LEGEND        = YES
+DOT_CLEANUP            = YES

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();
+}

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
+    */
+}

makefile

@@ -0,0 +1,11 @@
+non_recursive_merge_sort: non_recursive_merge_sort.cpp
+	g++ -std=c++17 -o non_recursive_merge_sort non_recursive_merge_sort.cpp
+.PHONY: test
+.PHONY: doc
+.PHONY: clean
+test: non_recursive_merge_sort
+	./non_recursive_merge_sort
+doc: doxy.txt
+	doxygen doxy.txt
+clean:
+	rm -fr non_recursive_merge_sort html

non_recursive_merge_sort.cpp

@@ -0,0 +1,114 @@
+/**
+ * Copyright 2020 @author Albirair
+ * @file
+ *
+ * A generic implementation of non-recursive merge sort.
+ */
+#include <cstddef>  // for size_t
+#include <utility>  // for std::move & std::remove_reference_t
+template<class Iterator>
+void merge(Iterator, Iterator, const Iterator, char[]);
+/// bottom-up merge sort which sorts elements in a non-decreasing order
+/**
+ * sorts elements non-recursively by breaking them into small segments, merging
+ * adjacent segments into larger sorted segments, then increasing the sizes of
+ * segments by factors of 2 and repeating the same process.
+ * best-case = worst-case = O(n log(n))
+ * @param first points to the first element
+ * @param last points to 1-step past the last element
+ * @param n the number of elements
+*/
+template<class Iterator>
+void non_recursive_merge_sort(const Iterator first, const Iterator last,
+                              const size_t n) {
+    // create a buffer large enough to store all elements
+    // dynamically allocated to comply with cpplint
+    char * buffer = new char[n * sizeof(*first)];
+    // buffer size can be optimized to largest power of 2 less than n elements
+    // divide the container into equally-sized segments whose length start at 1
+    // and keeps increasing by factors of 2
+    for (size_t length(1); length < n; length <<= 1) {
+        // merge adjacent segments whose number is n / (length * 2)
+        Iterator left(first);
+        for (size_t counter(n / (length << 1)); counter; --counter) {
+            Iterator right(left + length), end(right + length);
+            merge(left, right, end, buffer);
+            left = end;
+        }
+        // if the number of remaining elements (n * 2 % length) is longer
+        // than a segment, merge the remaining elements
+        if ((n & ((length << 1) - 1)) > length)
+            merge(left, left + length, last, buffer);
+    }
+    delete[] buffer;
+}
+/// merges 2 sorted adjacent segments into a larger sorted segment
+/**
+ * best-case = worst-case = O(n)
+ * @param l points to the left part
+ * @param r points to the right part, end of left part
+ * @param e points to end of right part
+ * @param b points at the buffer
+*/
+template<class Iterator>
+void merge(Iterator l, Iterator r, const Iterator e, char b[]) {
+    // create 2 pointers to point at the buffer
+    auto p(reinterpret_cast<std::remove_reference_t<decltype(*l)>*>(b)), c(p);
+    // move the left part of the segment
+    for (Iterator t(l); r != t; ++t)
+        *p++ = std::move(*t);
+    // while neither the buffer nor the right part has been exhausted
+    // move the smallest element of the two back to the container
+    while (e != r && c != p)
+        *l++ = std::move(*r < *c ? *r++ : *c++);
+    // notice only one of the two following loops will be executed
+    // while the right part hasn't bee exhausted, move it back
+    while (e != r)
+        *l++ = std::move(*r++);
+    // while the buffer hasn't bee exhausted, move it back
+    while (c != p)
+        *l++ = std::move(*c++);
+}
+/// bottom-up merge sort which sorts elements in a non-decreasing order
+/**
+ * @param first points to the first element
+ * @param n the number of elements
+*/
+template<class Iterator>
+void non_recursive_merge_sort(const Iterator first, const size_t n) {
+    non_recursive_merge_sort(first, first + n, n);
+}
+/// bottom-up merge sort which sorts elements in a non-decreasing order
+/**
+ * @param first points to the first element
+ * @param last points to 1-step past the last element
+*/
+template<class Iterator>
+void non_recursive_merge_sort(const Iterator first, const Iterator last) {
+    non_recursive_merge_sort(first, last, last - first);
+}
+/**
+ * @mainpage A demonstration of auto-generated documentation using Doxygen.
+ * Currently, it only creates output for non_recursive_merge_sort.cpp, but if
+ * it has proven its efficacy it can be expanded to other files.
+ * The configuration file is named doxy.txt and has been auto-generated too.
+*/
+// the remaining of this file is only for testing. It can erased to to convert
+// it into a header file for later re-use.
+#include <iostream>
+int main(int argc, char ** argv) {
+    int size;
+    std::cout << "Enter the number of elements : ";
+    std::cin >> size;
+    int * arr = new int[size];
+    for (int i = 0; i < size; ++i) {
+        std::cout << "arr[" << i << "] = ";
+        std::cin >> arr[i];
+    }
+    non_recursive_merge_sort(arr, size);
+    std::cout << "Sorted array\n";
+    for (int i = 0; i < size; ++i)
+        std::cout << "arr[" << i << "] = " << arr[i] << '\n';
+    delete[] arr;
+    return 0;
+}