OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: add random pivot quick sort algorithm (#1510)

Browse Source 
* feat: add random pivot quick sort algorithm, test cases included

* updating DIRECTORY.md

* docs: add proper docs for random pivot quick sort algorithm, code reformatted.

* fix: copy constructor bug fixed for TestCase class for random pivot quick sort algo

* docs and code reformatted according to standards

* c-style array declarations removed

* added minor suggestion in docs

* resource link added in docs

* docs formatted

* test function's docs added, using stl function for swap

* generator function migrated to namespace

* Update sorting/random_pivot_quick_sort.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* Update sorting/random_pivot_quick_sort.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* Update sorting/random_pivot_quick_sort.cpp

Co-authored-by: David Leal <halfpacho@gmail.com>

* docs fixed sorting/random pivot quick sort

* Apply suggestions from code review

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: David Leal <halfpacho@gmail.com>
This commit is contained in:
Nitin Sharma 2021-07-06 22:49:27 +05:30 committed by GitHub
parent 0c5c096991
commit 60ee52fd6a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 310 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
DIRECTORY.md
View File

@ -298,6 +298,7 @@
* [Quick Sort 3](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/quick_sort_3.cpp)
* [Radix Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort.cpp)
* [Radix Sort2](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort2.cpp)
* [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)
* [Shell Sort](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/shell_sort.cpp)

309
sorting/random_pivot_quick_sort.cpp Normal file
View File

@ -0,0 +1,309 @@
/**
* @file
* @brief Implementation of the [Random Pivot Quick Sort](https://www.sanfoundry.com/cpp-program-implement-quick-sort-using-randomisation) algorithm.
* @details
* * A random pivot quick sort algorithm is pretty much same as quick sort with a difference of having a logic of
* selecting next pivot element from the input array.
* * Where in quick sort is fast, but still can give you the time complexity of O(n^2) in worst case.
* * To avoid hitting the time complexity of O(n^2), we use the logic of randomize the selection process of pivot
* element.
*
* ### Logic
* * The logic is pretty simple, the only change is in the partitioning algorithm, which is selecting the
* pivot element.
* * Instead of selecting the last or the first element from array for pivot we use a random index to select
* pivot element.
* * This avoids hitting the O(n^2) time complexity in practical use cases.
*
* ### Partition Logic
* * Partitions are done such as numbers lower than the "pivot" element is arranged on the left side of the "pivot",
* and number larger than the "pivot" element are arranged on the right part of the array.
*
* ### Algorithm
* * Select the pivot element randomly using getRandomIndex() function from this namespace.
* * Initialize the pInd (partition index) from the start of the array.
* * Loop through the array from start to less than end. (from start to < end).
* (Inside the loop) :-
* * Check if the current element (arr[i]) is less than the pivot element in each iteration.
* * If current element in the iteration is less than the pivot element,
* then swap the elements at current index (i) and partition index (pInd) and increment the partition index by one.
* * At the end of the loop, swap the pivot element with partition index element.
* * Return the partition index from the function.
*
* @author [Nitin Sharma](https://github.com/foo290)
*/
#include <iostream> /// for IO operations
#include <ctime> /// for initializing random number generator
#include <cassert> /// for assert
#include <algorithm> /// for std::is_sorted(), std::swap()
#include <array> /// for std::array
#include <tuple> /// for returning multiple values form a function at once
/**
* @namespace sorting
* @brief Sorting algorithms
*/
namespace sorting {
/**
* @brief Functions for the [Random Pivot Quick Sort](https://www.sanfoundry.com/cpp-program-implement-quick-sort-using-randomisation) implementation
* @namespace random_pivot_quick_sort
*/
namespace random_pivot_quick_sort {
/**
* @brief Utility function to print the array
* @tparam T size of the array
* @param arr array used to print its content
* @returns void
* */
template<size_t T>
void showArray(std::array<int64_t , T> arr) {
for (int64_t i = 0; i < arr.size(); i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
}
/**
* @brief Takes the start and end indices of an array and returns a random int64_teger between the range of those two
* for selecting pivot element.
*
* @param start The starting index.
* @param end The ending index.
* @returns int64_t A random number between start and end index.
* */
int64_t getRandomIndex(int64_t start, int64_t end) {
srand(time(nullptr)); // Initialize random number generator.
int64_t randomPivotIndex = start + rand() % (end - start + 1);
return randomPivotIndex;
}
/**
* @brief A partition function which handles the partition logic of quick sort.
* @tparam size size of the array to be passed as argument.
* @param start The start index of the passed array
* @param end The ending index of the passed array
* @returns std::tuple<int64_t , std::array<int64_t , size>> A tuple of pivot index and pivot sorted array.
*/
template<size_t size>
std::tuple<int64_t , std::array<int64_t , size>> partition(std::array<int64_t , size> arr, int64_t start, int64_t end) {
int64_t pivot = arr[end]; // Randomly selected element will be here from caller function (quickSortRP()).
int64_t pInd = start;
for (int64_t i = start; i < end; i++) {
if (arr[i] <= pivot) {
std::swap(arr[i], arr[pInd]); // swapping the elements from current index to pInd.
pInd++;
}
}
std::swap(arr[pInd], arr[end]); // swapping the pivot element to its sorted position
return std::make_tuple(pInd, arr);
}
/**
* @brief Random pivot quick sort function. This function is the starting point of the algorithm.
* @tparam size size of the array to be passed as argument.
* @param start The start index of the passed array
* @param end The ending index of the passed array
* @returns std::array<int64_t , size> A fully sorted array in ascending order.
*/
template<size_t size>
std::array<int64_t , size> quickSortRP(std::array<int64_t , size> arr, int64_t start, int64_t end) {
if (start < end) {
int64_t randomIndex = getRandomIndex(start, end);
// switching the pivot with right most bound.
std::swap(arr[end], arr[randomIndex]);
int64_t pivotIndex = 0;
// getting pivot index and pivot sorted array.
std::tie(pivotIndex, arr) = partition(arr, start, end);
// Recursively calling
std::array<int64_t , arr.size()> rightSortingLeft = quickSortRP(arr, start, pivotIndex - 1);
std::array<int64_t , arr.size()> full_sorted = quickSortRP(rightSortingLeft, pivotIndex + 1, end);
arr = full_sorted;
}
return arr;
}
/**
* @brief A function utility to generate unsorted array of given size and range.
* @tparam size Size of the output array.
* @param from Stating of the range.
* @param to Ending of the range.
* @returns std::array<int64_t , size> Unsorted array of specified size.
* */
template<size_t size>
std::array<int64_t , size> generateUnsortedArray(int64_t from, int64_t to) {
srand(time(nullptr));
std::array<int64_t , size> unsortedArray{};
assert(from < to);
int64_t i = 0;
while (i < size) {
int64_t randomNum = from + rand() % (to - from + 1);
if (randomNum) {
unsortedArray[i] = randomNum;
i++;
}
}
return unsortedArray;
}
} // namespace random_pivot_quick_sort
} // namespace sorting
/**
* @brief a class containing the necessary test cases
*/
class TestCases {
private:
/**
* @brief A function to print64_t given message on console.
* @tparam T Type of the given message.
* @returns void
* */
template<typename T>
void log(T msg) {
// It's just to avoid writing cout and endl
std::cout << "[TESTS] : ---> " << msg << std::endl;
}
public:
/**
* @brief Executes test cases
* @returns void
* */
void runTests() {
log("Running Tests...");
testCase_1();
testCase_2();
testCase_3();
log("Test Cases over!");
std::cout << std::endl;
}
/**
* @brief A test case with single input
* @returns void
* */
void testCase_1() {
const int64_t inputSize = 1;
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
log("This is test case 1 for Random Pivot Quick Sort Algorithm : ");
log("Description:");
log(" EDGE CASE : Only contains one element");
std::array<int64_t , inputSize> unsorted_arr{2};
int64_t start = 0;
int64_t end = unsorted_arr.size() - 1; // length - 1
log("Running algorithm of data of length 50 ...");
std::array<int64_t , unsorted_arr.size()> sorted_arr = sorting::random_pivot_quick_sort::quickSortRP(
unsorted_arr, start, end
);
log("Algorithm finished!");
log("Checking assert expression...");
assert(std::is_sorted(sorted_arr.begin(), sorted_arr.end()));
log("Assertion check passed!");
log("[PASS] : TEST CASE 1 PASS!");
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
}
/**
* @brief A test case with input array of length 500
* @returns void
* */
void testCase_2() {
const int64_t inputSize = 500;
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
log("Description:");
log(" BIG INPUT : Contains 500 elements and repeated elements");
log("This is test case 2 for Random Pivot Quick Sort Algorithm : ");
std::array<int64_t , inputSize> unsorted_arr = sorting::random_pivot_quick_sort::generateUnsortedArray<inputSize>(1, 10000);
int64_t start = 0;
int64_t end = unsorted_arr.size() - 1; // length - 1
log("Running algorithm of data of length 500 ...");
std::array<int64_t , unsorted_arr.size()> sorted_arr = sorting::random_pivot_quick_sort::quickSortRP(
unsorted_arr, start, end
);
log("Algorithm finished!");
log("Checking assert expression...");
assert(std::is_sorted(sorted_arr.begin(), sorted_arr.end()));
log("Assertion check passed!");
log("[PASS] : TEST CASE 2 PASS!");
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
}
/**
* @brief A test case with array of length 1000.
* @returns void
* */
void testCase_3() {
const int64_t inputSize = 1000;
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
log("This is test case 3 for Random Pivot Quick Sort Algorithm : ");
log("Description:");
log(" LARGE INPUT : Contains 1000 elements and repeated elements");
std::array<int64_t , inputSize> unsorted_arr = sorting::random_pivot_quick_sort::generateUnsortedArray<inputSize>(1, 10000);
int64_t start = 0;
int64_t end = unsorted_arr.size() - 1; // length - 1
log("Running algorithm...");
std::array<int64_t , unsorted_arr.size()> sorted_arr = sorting::random_pivot_quick_sort::quickSortRP(
unsorted_arr, start, end
);
log("Algorithm finished!");
log("Checking assert expression...");
assert(std::is_sorted(sorted_arr.begin(), sorted_arr.end()));
log("Assertion check passed!");
log("[PASS] : TEST CASE 3 PASS!");
log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
}
};
/**
* @brief Self-test implementations
* @returns void
*/
static void test() {
TestCases tc = TestCases();
tc.runTests();
}
/**
* @brief Main function
* @param argc commandline argument count (ignored)
* @param argv commandline array of arguments (ignored)
* @returns 0 on exit
*/
int main(int argc, char *argv[]) {
test(); // Executes various test cases.
const int64_t inputSize = 10;
std::array<int64_t , inputSize> unsorted_array = sorting::random_pivot_quick_sort::generateUnsortedArray<inputSize>(50, 1000);
std::cout << "Unsorted array is : " << std::endl;
sorting::random_pivot_quick_sort::showArray(unsorted_array);
std::array<int64_t , inputSize> sorted_array = sorting::random_pivot_quick_sort::quickSortRP(
unsorted_array, 0,
unsorted_array.size() - 1
);
std::cout << "Sorted array is : " << std::endl;
sorting::random_pivot_quick_sort::showArray(sorted_array);
return 0;
}