From a6bbe050f7b56f4351bddf05fc3f8cf7c1d63711 Mon Sep 17 00:00:00 2001 From: Jxtopher <39927513+Jxtopher@users.noreply.github.com> Date: Sun, 5 Sep 2021 19:37:31 +0200 Subject: [PATCH 1/2] fix: Add `return 0` in `bactracking/magic_sequence.cpp` (#1589) * Update magic_sequence.cpp * clang-format and clang-tidy fixes for ff127de6 * Update backtracking/magic_sequence.cpp Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: Abhinn Mishra <49574460+mishraabhinn@users.noreply.github.com> Co-authored-by: David Leal --- backtracking/magic_sequence.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/backtracking/magic_sequence.cpp b/backtracking/magic_sequence.cpp index 13a260dc9..478dd28dc 100644 --- a/backtracking/magic_sequence.cpp +++ b/backtracking/magic_sequence.cpp @@ -132,4 +132,5 @@ int main() { backtracking::magic_sequence::print(item); } } + return 0; } From ea9ae3a91ba42d78867293f24914fd42ed8950b4 Mon Sep 17 00:00:00 2001 From: Tushar Khanduri <62638544+Tushar-K24@users.noreply.github.com> Date: Sun, 5 Sep 2021 23:20:51 +0530 Subject: [PATCH 2/2] feat: Add the Selection Sort Recursive algorithm (#1578) * Create selection_sort_recursive.cpp * updating DIRECTORY.md * Add: Description of Algorithm * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * clang-format and clang-tidy fixes for 8f466c86 * Apply suggestions from code review * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update selection_sort_recursive.cpp * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * clang-format and clang-tidy fixes for bfda3660 * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: David Leal * Update sorting/selection_sort_recursive.cpp Co-authored-by: Ayaan Khan Co-authored-by: David Leal Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: Ayaan Khan --- DIRECTORY.md | 1 + sorting/selection_sort_recursive.cpp | 131 +++++++++++++++++++++++++++ 2 files changed, 132 insertions(+) create mode 100644 sorting/selection_sort_recursive.cpp diff --git a/DIRECTORY.md b/DIRECTORY.md index 97a648755..b34e8afe6 100644 --- a/DIRECTORY.md +++ b/DIRECTORY.md @@ -319,6 +319,7 @@ * [Random Pivot Quick Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/random_pivot_quick_sort.cpp) * [Recursive Bubble Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/recursive_bubble_sort.cpp) * [Selection Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort.cpp) + * [Selection Sort Recursive](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort_recursive.cpp) * [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp) * [Shell Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort2.cpp) * [Slow Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/slow_sort.cpp) diff --git a/sorting/selection_sort_recursive.cpp b/sorting/selection_sort_recursive.cpp new file mode 100644 index 000000000..83f1a21b7 --- /dev/null +++ b/sorting/selection_sort_recursive.cpp @@ -0,0 +1,131 @@ +/** + * @file + * @brief Implementation of the [Selection + * sort](https://en.wikipedia.org/wiki/Selection_sort) + * implementation using recursion + * @details + * The selection sort algorithm divides the input list into two parts: a sorted + * sublist of items which is built up from left to right at the front (left) of + * the list, and a sublist of the remaining unsorted items that occupy the rest + * of the list. Initially, the sorted sublist is empty, and the unsorted sublist + * is the entire input list. The algorithm proceeds by finding the smallest (or + * largest, depending on the sorting order) element in the unsorted sublist, + * exchanging (swapping) it with the leftmost unsorted element (putting it in + * sorted order), and moving the sublist boundaries one element to the right. + * + * ### Implementation + * FindMinIndex + * This function finds the minimum element of the array(list) recursively by + * simply comparing the minimum element of array reduced size by 1 and compares + * it to the last element of the array to find the minimum of the whole array. + * + * SelectionSortRecursive + * Just like selection sort, it divides the list into two parts (i.e.: sorted + * and unsorted) and finds the minimum of the unsorted array. By calling the + * `FindMinIndex` function, it swaps the minimum element with the first element + * of the list, and then solves recursively for the remaining unsorted list. + * @author [Tushar Khanduri](https://github.com/Tushar-K24) + */ + +#include /// for std::is_sorted +#include /// for assert +#include /// for std::swap and io operations +#include /// for std::vector + +/** + * @namespace sorting + * @brief Sorting algorithms + */ +namespace sorting { +/** + * @namespace selection_sort_recursive + * @brief Functions for the [Selection + * sort](https://en.wikipedia.org/wiki/Selection_sort) + * implementation using recursion + */ +namespace selection_sort_recursive { +/** + * @brief The main function finds the index of the minimum element + * @tparam T type of array + * @param in_arr array whose minimum element is to be returned + * @param current_position position/index from where the in_arr starts + * @returns index of the minimum element + */ +template +uint64_t findMinIndex(const std::vector &in_arr, uint64_t current_position = 0) { + if (current_position + 1 == in_arr.size()) { + return current_position; + } + uint64_t answer = findMinIndex(in_arr, current_position + 1); + if (in_arr[current_position] < in_arr[answer]) { + answer = current_position; + } + return answer; +} + +/** + * @brief The main function implements Selection sort + * @tparam T type of array + * @param in_arr array to be sorted, + * @param current_position position/index from where the in_arr starts + * @returns void + */ +template +void selectionSortRecursive(std::vector &in_arr, + uint64_t current_position = 0) { + if (current_position == in_arr.size()) { + return; + } + uint64_t min_element_idx = + selection_sort_recursive::findMinIndex(in_arr, current_position); + if (min_element_idx != current_position) { + std::swap(in_arr[min_element_idx], in_arr[current_position]); + } + selectionSortRecursive(in_arr, current_position + 1); +} +} // namespace selection_sort_recursive +} // namespace sorting + +/** + * @brief Self-test implementations + * @returns void + */ +static void test() { + // 1st test + // [1, 0, 2, 1] return [0, 1, 1, 2] + std::vector array1 = {0, 1, 1, 2}; + std::cout << "1st test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array1); + assert(std::is_sorted(std::begin(array1), std::end(array1))); + std::cout << "passed" << std::endl; + // 2nd test + // [1, 0, 0, 1, 1, 0, 2, 1] return [0, 0, 0, 1, 1, 1, 1, 2] + std::vector array2 = {1, 0, 0, 1, 1, 0, 2, 1}; + std::cout << "2nd test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array2); + assert(std::is_sorted(std::begin(array2), std::end(array2))); + std::cout << "passed" << std::endl; + // 3rd test + // [1, 1, 0, 0, 1, 2, 2, 0, 2, 1] return [0, 0, 0, 1, 1, 1, 1, 2, 2, 2] + std::vector array3 = {1, 1, 0, 0, 1, 2, 2, 0, 2, 1}; + std::cout << "3rd test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array3); + assert(std::is_sorted(std::begin(array3), std::end(array3))); + std::cout << "passed" << std::endl; + // 4th test + // [2, 2, 2, 0, 0, 1, 1] return [0, 0, 1, 1, 2, 2, 2] + std::vector array4 = {2, 2, 2, 0, 0, 1, 1}; + std::cout << "4th test... "; + sorting::selection_sort_recursive::selectionSortRecursive(array4); + assert(std::is_sorted(std::begin(array4), std::end(array4))); + std::cout << "passed" << std::endl; +} + +/** + * @brief Main function + * @returns 0 on exit + */ +int main() { + test(); // run self-test implementations + return 0; +}