From c844979648a179c418c42e4f94a29d10ed4250f3 Mon Sep 17 00:00:00 2001 From: cclauss Date: Sat, 25 Apr 2020 15:23:13 +0000 Subject: [PATCH] deploy: 57ea7b1f9d6f440aef0cdb6b8ccd111ba3f5c50e --- BeadSort.cpp | 63 +++ BitonicSort.cpp | 76 ++++ Bubble Sort.cpp | 83 ++++ CocktailSelectionSort.cpp | 109 +++++ CountingSortString.cpp | 41 ++ Counting_Sort.cpp | 66 ++++ Insertion Sort.cpp | 40 ++ Merge Sort.cpp | 93 +++++ NumericStringSort.cpp | 62 +++ OddEven Sort.cpp | 61 +++ Quick Sort.cpp | 67 ++++ Radix Sort.cpp | 68 ++++ Selection Sort.cpp | 39 ++ Shell Sort.cpp | 45 +++ Slow Sort.cpp | 57 +++ Tim Sort.cpp | 116 ++++++ bucketSort.cpp | 42 ++ combsort.cpp | 59 +++ doxy.txt | 374 ++++++++++++++++++ heap_sort.cpp | 52 +++ bc_s.png => html/bc_s.png | Bin bdwn.png => html/bdwn.png | Bin closed.png => html/closed.png | Bin doc.png => html/doc.png | Bin doxygen.css => html/doxygen.css | 0 doxygen.png => html/doxygen.png | Bin dynsections.js => html/dynsections.js | 0 files.html => html/files.html | 0 folderclosed.png => html/folderclosed.png | Bin folderopen.png => html/folderopen.png | Bin globals.html => html/globals.html | 0 globals_func.html => html/globals_func.html | 0 graph_legend.html => html/graph_legend.html | 0 graph_legend.md5 => html/graph_legend.md5 | 0 graph_legend.png => html/graph_legend.png | Bin index.html => html/index.html | 0 jquery.js => html/jquery.js | 0 menu.js => html/menu.js | 0 menudata.js => html/menudata.js | 0 nav_f.png => html/nav_f.png | Bin nav_g.png => html/nav_g.png | Bin nav_h.png => html/nav_h.png | Bin .../non__recursive__merge__sort_8cpp.html | 0 ...non__recursive__merge__sort_8cpp__incl.map | 0 ...non__recursive__merge__sort_8cpp__incl.md5 | 0 ...non__recursive__merge__sort_8cpp__incl.png | Bin open.png => html/open.png | Bin {search => html/search}/all_0.html | 0 {search => html/search}/all_0.js | 0 {search => html/search}/all_1.html | 0 {search => html/search}/all_1.js | 0 {search => html/search}/all_2.html | 0 {search => html/search}/all_2.js | 0 {search => html/search}/close.png | Bin {search => html/search}/files_0.html | 0 {search => html/search}/files_0.js | 0 {search => html/search}/functions_0.html | 0 {search => html/search}/functions_0.js | 0 {search => html/search}/functions_1.html | 0 {search => html/search}/functions_1.js | 0 {search => html/search}/mag_sel.png | Bin {search => html/search}/nomatches.html | 0 {search => html/search}/pages_0.html | 0 {search => html/search}/pages_0.js | 0 {search => html/search}/search.css | 0 {search => html/search}/search.js | 0 {search => html/search}/search_l.png | Bin {search => html/search}/search_m.png | Bin {search => html/search}/search_r.png | Bin {search => html/search}/searchdata.js | 0 splitbar.png => html/splitbar.png | Bin sync_off.png => html/sync_off.png | Bin sync_on.png => html/sync_on.png | Bin tab_a.png => html/tab_a.png | Bin tab_b.png => html/tab_b.png | Bin tab_h.png => html/tab_h.png | Bin tab_s.png => html/tab_s.png | Bin tabs.css => html/tabs.css | 0 library_sort.cpp | 90 +++++ makefile | 11 + non_recursive_merge_sort.cpp | 114 ++++++ 81 files changed, 1828 insertions(+) create mode 100644 BeadSort.cpp create mode 100644 BitonicSort.cpp create mode 100644 Bubble Sort.cpp create mode 100644 CocktailSelectionSort.cpp create mode 100644 CountingSortString.cpp create mode 100644 Counting_Sort.cpp create mode 100644 Insertion Sort.cpp create mode 100644 Merge Sort.cpp create mode 100644 NumericStringSort.cpp create mode 100644 OddEven Sort.cpp create mode 100644 Quick Sort.cpp create mode 100644 Radix Sort.cpp create mode 100644 Selection Sort.cpp create mode 100644 Shell Sort.cpp create mode 100644 Slow Sort.cpp create mode 100644 Tim Sort.cpp create mode 100644 bucketSort.cpp create mode 100644 combsort.cpp create mode 100644 doxy.txt create mode 100644 heap_sort.cpp rename bc_s.png => html/bc_s.png (100%) rename bdwn.png => html/bdwn.png (100%) rename closed.png => html/closed.png (100%) rename doc.png => html/doc.png (100%) rename doxygen.css => html/doxygen.css (100%) rename doxygen.png => html/doxygen.png (100%) rename dynsections.js => html/dynsections.js (100%) rename files.html => html/files.html (100%) rename folderclosed.png => html/folderclosed.png (100%) rename folderopen.png => html/folderopen.png (100%) rename globals.html => html/globals.html (100%) rename globals_func.html => html/globals_func.html (100%) rename graph_legend.html => html/graph_legend.html (100%) rename graph_legend.md5 => html/graph_legend.md5 (100%) rename graph_legend.png => html/graph_legend.png (100%) rename index.html => html/index.html (100%) rename jquery.js => html/jquery.js (100%) rename menu.js => html/menu.js (100%) rename menudata.js => html/menudata.js (100%) rename nav_f.png => html/nav_f.png (100%) rename nav_g.png => html/nav_g.png (100%) rename nav_h.png => html/nav_h.png (100%) rename non__recursive__merge__sort_8cpp.html => html/non__recursive__merge__sort_8cpp.html (100%) rename non__recursive__merge__sort_8cpp__incl.map => html/non__recursive__merge__sort_8cpp__incl.map (100%) rename non__recursive__merge__sort_8cpp__incl.md5 => html/non__recursive__merge__sort_8cpp__incl.md5 (100%) rename non__recursive__merge__sort_8cpp__incl.png => html/non__recursive__merge__sort_8cpp__incl.png (100%) rename open.png => html/open.png (100%) rename {search => html/search}/all_0.html (100%) rename {search => html/search}/all_0.js (100%) rename {search => html/search}/all_1.html (100%) rename {search => html/search}/all_1.js (100%) rename {search => html/search}/all_2.html (100%) rename {search => html/search}/all_2.js (100%) rename {search => html/search}/close.png (100%) rename {search => html/search}/files_0.html (100%) rename {search => html/search}/files_0.js (100%) rename {search => html/search}/functions_0.html (100%) rename {search => html/search}/functions_0.js (100%) rename {search => html/search}/functions_1.html (100%) rename {search => html/search}/functions_1.js (100%) rename {search => html/search}/mag_sel.png (100%) rename {search => html/search}/nomatches.html (100%) rename {search => html/search}/pages_0.html (100%) rename {search => html/search}/pages_0.js (100%) rename {search => html/search}/search.css (100%) rename {search => html/search}/search.js (100%) rename {search => html/search}/search_l.png (100%) rename {search => html/search}/search_m.png (100%) rename {search => html/search}/search_r.png (100%) rename {search => html/search}/searchdata.js (100%) rename splitbar.png => html/splitbar.png (100%) rename sync_off.png => html/sync_off.png (100%) rename sync_on.png => html/sync_on.png (100%) rename tab_a.png => html/tab_a.png (100%) rename tab_b.png => html/tab_b.png (100%) rename tab_h.png => html/tab_h.png (100%) rename tab_s.png => html/tab_s.png (100%) rename tabs.css => html/tabs.css (100%) create mode 100644 library_sort.cpp create mode 100644 makefile create mode 100644 non_recursive_merge_sort.cpp 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; +}