diff --git a/BeadSort.cpp b/BeadSort.cpp new file mode 100644 index 000000000..c8e27b250 --- /dev/null +++ b/BeadSort.cpp @@ -0,0 +1,63 @@ +// C++ program to implement gravity/bead sort +#include +#include +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; +} diff --git a/BitonicSort.cpp b/BitonicSort.cpp new file mode 100644 index 000000000..6ad2489d2 --- /dev/null +++ b/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 +#include +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; +} diff --git a/Bubble Sort.cpp b/Bubble Sort.cpp new file mode 100644 index 000000000..b160ac479 --- /dev/null +++ b/Bubble Sort.cpp @@ -0,0 +1,83 @@ +//Bubble Sort + +#include +#include +using namespace std; + +int main() +{ + int n; + short swap_check = 1; + cout << "Enter the amount of numbers to sort: "; + cin >> n; + vector 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. +* / diff --git a/CocktailSelectionSort.cpp b/CocktailSelectionSort.cpp new file mode 100644 index 000000000..cac6a3618 --- /dev/null +++ b/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 +using namespace std; + +//Iterative Version + +void CocktailSelectionSort(vector &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 &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 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; +} diff --git a/CountingSortString.cpp b/CountingSortString.cpp new file mode 100644 index 000000000..6179e5d11 --- /dev/null +++ b/CountingSortString.cpp @@ -0,0 +1,41 @@ +// C++ Program for counting sort +#include + +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; +} diff --git a/Counting_Sort.cpp b/Counting_Sort.cpp new file mode 100644 index 000000000..bda37bbd8 --- /dev/null +++ b/Counting_Sort.cpp @@ -0,0 +1,66 @@ +#include +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; +} diff --git a/Insertion Sort.cpp b/Insertion Sort.cpp new file mode 100644 index 000000000..2563acaf8 --- /dev/null +++ b/Insertion Sort.cpp @@ -0,0 +1,40 @@ +//Insertion Sort + +#include +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; +} diff --git a/Merge Sort.cpp b/Merge Sort.cpp new file mode 100644 index 000000000..b8edc8851 --- /dev/null +++ b/Merge Sort.cpp @@ -0,0 +1,93 @@ +#include +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; +} diff --git a/NumericStringSort.cpp b/NumericStringSort.cpp new file mode 100644 index 000000000..02f6964ba --- /dev/null +++ b/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 +#include +#include +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 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; +} diff --git a/OddEven Sort.cpp b/OddEven Sort.cpp new file mode 100644 index 000000000..62842c174 --- /dev/null +++ b/OddEven Sort.cpp @@ -0,0 +1,61 @@ +/* C++ implementation Odd Even Sort */ +#include +#include + +using namespace std; + +void oddEven(vector &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 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 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; +} diff --git a/Quick Sort.cpp b/Quick Sort.cpp new file mode 100644 index 000000000..0b807898f --- /dev/null +++ b/Quick Sort.cpp @@ -0,0 +1,67 @@ +/* C implementation QuickSort */ +#include +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; +} diff --git a/Radix Sort.cpp b/Radix Sort.cpp new file mode 100644 index 000000000..09c91bb22 --- /dev/null +++ b/Radix Sort.cpp @@ -0,0 +1,68 @@ +#include +#include +#include +#include +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; +} \ No newline at end of file diff --git a/Selection Sort.cpp b/Selection Sort.cpp new file mode 100644 index 000000000..5b8724141 --- /dev/null +++ b/Selection Sort.cpp @@ -0,0 +1,39 @@ +//Selection Sort + +#include +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"; + } +} diff --git a/Shell Sort.cpp b/Shell Sort.cpp new file mode 100644 index 000000000..b08c7ffd8 --- /dev/null +++ b/Shell Sort.cpp @@ -0,0 +1,45 @@ +#include +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; +} diff --git a/Slow Sort.cpp b/Slow Sort.cpp new file mode 100644 index 000000000..f8f7e74b8 --- /dev/null +++ b/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 +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; +} diff --git a/Tim Sort.cpp b/Tim Sort.cpp new file mode 100644 index 000000000..14d3a04d0 --- /dev/null +++ b/Tim Sort.cpp @@ -0,0 +1,116 @@ +// C++ program to perform TimSort. +#include +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; +} diff --git a/bucketSort.cpp b/bucketSort.cpp new file mode 100644 index 000000000..0ffbf8e4c --- /dev/null +++ b/bucketSort.cpp @@ -0,0 +1,42 @@ +// C++ program to sort an array using bucket sort +#include +#include +#include +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 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; +} diff --git a/combsort.cpp b/combsort.cpp new file mode 100644 index 000000000..2209c96fc --- /dev/null +++ b/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 + +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; +} diff --git a/doxy.txt b/doxy.txt new file mode 100644 index 000000000..68079276e --- /dev/null +++ b/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 diff --git a/heap_sort.cpp b/heap_sort.cpp new file mode 100644 index 000000000..9948bb821 --- /dev/null +++ b/heap_sort.cpp @@ -0,0 +1,52 @@ +#include +#include + +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(); +} diff --git a/bc_s.png b/html/bc_s.png similarity index 100% rename from bc_s.png rename to html/bc_s.png diff --git a/bdwn.png b/html/bdwn.png similarity index 100% rename from bdwn.png rename to html/bdwn.png diff --git a/closed.png b/html/closed.png similarity index 100% rename from closed.png rename to html/closed.png diff --git a/doc.png b/html/doc.png similarity index 100% rename from doc.png rename to html/doc.png diff --git a/doxygen.css b/html/doxygen.css similarity index 100% rename from doxygen.css rename to html/doxygen.css diff --git a/doxygen.png b/html/doxygen.png similarity index 100% rename from doxygen.png rename to html/doxygen.png diff --git a/dynsections.js b/html/dynsections.js similarity index 100% rename from dynsections.js rename to html/dynsections.js diff --git a/files.html b/html/files.html similarity index 100% rename from files.html rename to html/files.html diff --git a/folderclosed.png b/html/folderclosed.png similarity index 100% rename from folderclosed.png rename to html/folderclosed.png diff --git a/folderopen.png b/html/folderopen.png similarity index 100% rename from folderopen.png rename to html/folderopen.png diff --git a/globals.html b/html/globals.html similarity index 100% rename from globals.html rename to html/globals.html diff --git a/globals_func.html b/html/globals_func.html similarity index 100% rename from globals_func.html rename to html/globals_func.html diff --git a/graph_legend.html b/html/graph_legend.html similarity index 100% rename from graph_legend.html rename to html/graph_legend.html diff --git a/graph_legend.md5 b/html/graph_legend.md5 similarity index 100% rename from graph_legend.md5 rename to html/graph_legend.md5 diff --git a/graph_legend.png b/html/graph_legend.png similarity index 100% rename from graph_legend.png rename to html/graph_legend.png diff --git a/index.html b/html/index.html similarity index 100% rename from index.html rename to html/index.html diff --git a/jquery.js b/html/jquery.js similarity index 100% rename from jquery.js rename to html/jquery.js diff --git a/menu.js b/html/menu.js similarity index 100% rename from menu.js rename to html/menu.js diff --git a/menudata.js b/html/menudata.js similarity index 100% rename from menudata.js rename to html/menudata.js diff --git a/nav_f.png b/html/nav_f.png similarity index 100% rename from nav_f.png rename to html/nav_f.png diff --git a/nav_g.png b/html/nav_g.png similarity index 100% rename from nav_g.png rename to html/nav_g.png diff --git a/nav_h.png b/html/nav_h.png similarity index 100% rename from nav_h.png rename to html/nav_h.png diff --git a/non__recursive__merge__sort_8cpp.html b/html/non__recursive__merge__sort_8cpp.html similarity index 100% rename from non__recursive__merge__sort_8cpp.html rename to html/non__recursive__merge__sort_8cpp.html diff --git a/non__recursive__merge__sort_8cpp__incl.map b/html/non__recursive__merge__sort_8cpp__incl.map similarity index 100% rename from non__recursive__merge__sort_8cpp__incl.map rename to html/non__recursive__merge__sort_8cpp__incl.map diff --git a/non__recursive__merge__sort_8cpp__incl.md5 b/html/non__recursive__merge__sort_8cpp__incl.md5 similarity index 100% rename from non__recursive__merge__sort_8cpp__incl.md5 rename to html/non__recursive__merge__sort_8cpp__incl.md5 diff --git a/non__recursive__merge__sort_8cpp__incl.png b/html/non__recursive__merge__sort_8cpp__incl.png similarity index 100% rename from non__recursive__merge__sort_8cpp__incl.png rename to html/non__recursive__merge__sort_8cpp__incl.png diff --git a/open.png b/html/open.png similarity index 100% rename from open.png rename to html/open.png diff --git a/search/all_0.html b/html/search/all_0.html similarity index 100% rename from search/all_0.html rename to html/search/all_0.html diff --git a/search/all_0.js b/html/search/all_0.js similarity index 100% rename from search/all_0.js rename to html/search/all_0.js diff --git a/search/all_1.html b/html/search/all_1.html similarity index 100% rename from search/all_1.html rename to html/search/all_1.html diff --git a/search/all_1.js b/html/search/all_1.js similarity index 100% rename from search/all_1.js rename to html/search/all_1.js diff --git a/search/all_2.html b/html/search/all_2.html similarity index 100% rename from search/all_2.html rename to html/search/all_2.html diff --git a/search/all_2.js b/html/search/all_2.js similarity index 100% rename from search/all_2.js rename to html/search/all_2.js diff --git a/search/close.png b/html/search/close.png similarity index 100% rename from search/close.png rename to html/search/close.png diff --git a/search/files_0.html b/html/search/files_0.html similarity index 100% rename from search/files_0.html rename to html/search/files_0.html diff --git a/search/files_0.js b/html/search/files_0.js similarity index 100% rename from search/files_0.js rename to html/search/files_0.js diff --git a/search/functions_0.html b/html/search/functions_0.html similarity index 100% rename from search/functions_0.html rename to html/search/functions_0.html diff --git a/search/functions_0.js b/html/search/functions_0.js similarity index 100% rename from search/functions_0.js rename to html/search/functions_0.js diff --git a/search/functions_1.html b/html/search/functions_1.html similarity index 100% rename from search/functions_1.html rename to html/search/functions_1.html diff --git a/search/functions_1.js b/html/search/functions_1.js similarity index 100% rename from search/functions_1.js rename to html/search/functions_1.js diff --git a/search/mag_sel.png b/html/search/mag_sel.png similarity index 100% rename from search/mag_sel.png rename to html/search/mag_sel.png diff --git a/search/nomatches.html b/html/search/nomatches.html similarity index 100% rename from search/nomatches.html rename to html/search/nomatches.html diff --git a/search/pages_0.html b/html/search/pages_0.html similarity index 100% rename from search/pages_0.html rename to html/search/pages_0.html diff --git a/search/pages_0.js b/html/search/pages_0.js similarity index 100% rename from search/pages_0.js rename to html/search/pages_0.js diff --git a/search/search.css b/html/search/search.css similarity index 100% rename from search/search.css rename to html/search/search.css diff --git a/search/search.js b/html/search/search.js similarity index 100% rename from search/search.js rename to html/search/search.js diff --git a/search/search_l.png b/html/search/search_l.png similarity index 100% rename from search/search_l.png rename to html/search/search_l.png diff --git a/search/search_m.png b/html/search/search_m.png similarity index 100% rename from search/search_m.png rename to html/search/search_m.png diff --git a/search/search_r.png b/html/search/search_r.png similarity index 100% rename from search/search_r.png rename to html/search/search_r.png diff --git a/search/searchdata.js b/html/search/searchdata.js similarity index 100% rename from search/searchdata.js rename to html/search/searchdata.js diff --git a/splitbar.png b/html/splitbar.png similarity index 100% rename from splitbar.png rename to html/splitbar.png diff --git a/sync_off.png b/html/sync_off.png similarity index 100% rename from sync_off.png rename to html/sync_off.png diff --git a/sync_on.png b/html/sync_on.png similarity index 100% rename from sync_on.png rename to html/sync_on.png diff --git a/tab_a.png b/html/tab_a.png similarity index 100% rename from tab_a.png rename to html/tab_a.png diff --git a/tab_b.png b/html/tab_b.png similarity index 100% rename from tab_b.png rename to html/tab_b.png diff --git a/tab_h.png b/html/tab_h.png similarity index 100% rename from tab_h.png rename to html/tab_h.png diff --git a/tab_s.png b/html/tab_s.png similarity index 100% rename from tab_s.png rename to html/tab_s.png diff --git a/tabs.css b/html/tabs.css similarity index 100% rename from tabs.css rename to html/tabs.css diff --git a/library_sort.cpp b/library_sort.cpp new file mode 100644 index 000000000..6f1ab6245 --- /dev/null +++ b/library_sort.cpp @@ -0,0 +1,90 @@ +#include +#include + +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 + */ +} diff --git a/makefile b/makefile new file mode 100644 index 000000000..21d3186c6 --- /dev/null +++ b/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 diff --git a/non_recursive_merge_sort.cpp b/non_recursive_merge_sort.cpp new file mode 100644 index 000000000..c6ca56376 --- /dev/null +++ b/non_recursive_merge_sort.cpp @@ -0,0 +1,114 @@ +/** + * Copyright 2020 @author Albirair + * @file + * + * A generic implementation of non-recursive merge sort. + */ +#include // for size_t +#include // for std::move & std::remove_reference_t +template +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 +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 +void merge(Iterator l, Iterator r, const Iterator e, char b[]) { + // create 2 pointers to point at the buffer + auto p(reinterpret_cast*>(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 +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 +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 +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; +}