From 0202a11fd6093dbcd3cb783d7b05c27de9125694 Mon Sep 17 00:00:00 2001 From: Nothinormuch Date: Sun, 18 Jan 2026 14:16:48 +0530 Subject: [PATCH] feat: add quick select algorithm using median of medians --- misc/quick_select.c | 285 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 285 insertions(+) create mode 100644 misc/quick_select.c diff --git a/misc/quick_select.c b/misc/quick_select.c new file mode 100644 index 0000000000..bd1d5eb2f1 --- /dev/null +++ b/misc/quick_select.c @@ -0,0 +1,285 @@ +/** + * @file + * @brief Kth largest element in linear time [Wikipedia: Selection Algorithm](https://en.wikipedia.org/wiki/Selection_algorithm)[Median of Medians](https://en.wikipedia.org/wiki/Median_of_medians) + * @details + * Quick Select is a linear-time algorithm for finding the kth largest element in an unsorted array. + * It uses the median-of-medians algorithm to guarantee a good pivot selection, achieving O(n) + * average time complexity and avoiding the O(n^2) worst-case of naive quickselect. + * @author [Nothinormuch](https://github.com/Nothinormuch/) + */ + +#include +#include +#include +#include + +/** + * @brief Prints a portion of an array + */ +void print_arr(int * arr, int start, int stop){ + printf("[%d",arr[start]); + for(int i = start+1; i < stop+1; i ++){ + printf(",%d",arr[i]); + } + printf("]"); +} + +/** + * @brief Swaps two elements in an array + * @param arr array pointer + * @param i Index of first element + * @param j Index of second element + */ +void swap(int * arr, int i, int j){ + int tmp = arr[i]; + arr[i] = arr[j]; + arr[j] = tmp; +} + +int partition(int * arr, int start, int stop, int pivot_value); +int median_of_medians(int * arr, int start, int stop); +int median_of_medians_helper(int * arr, int start, int stop); + +/** + * @brief Partitions array so elements greater than pivot are on the left + * @details + * Rearranges elements so that all elements greater than the pivot_value + * are moved to the left side, smaller elements remain on the right. + * The pivot is placed at the boundary between these two groups. + * @param arr Pointer to the array + * @param start Starting index of the partition range + * @param stop Ending index of the partition range + * @param pivot_value The value to partition around + * @returns The final position of the pivot element + */ +int partition(int * arr, int start, int stop, int pivot_value){ + int i = start; // boundary pointer between larger and smaller elements + + // Move all elements greater than pivot to the left + for (int j = start; j <= stop; j++){ + if (arr[j] > pivot_value){ + swap(arr, i, j); + i++; + } + } + + // Find and place the pivot at position i + for (int j = i; j <= stop; j++){ + if (arr[j] == pivot_value){ + swap(arr, i, j); + break; + } + } + return i; +} + +/** + * @brief Finds a good pivot value using the median-of-medians algorithm + * @details + * Uses a divide-and-conquer strategy: divides the array into groups of 5, + * finds the median of each group, then recursively finds the median of those medians. + * This guarantees O(n) linear time complexity regardless of input distribution. + * @param arr Pointer to the array + * @param start Starting index of the range + * @param stop Ending index of the range + * @returns The median value (suitable for use as a pivot) + */ +int median_of_medians(int * arr, int start, int stop){ + int len = stop - start + 1; + + // Base case: small arrays just get sorted and return middle element + if (len <= 5){ + for (int i = start; i <= stop; i++){ + for (int j = start; j < stop - (i - start); j++){ + if (arr[j] > arr[j + 1]){ + swap(arr, j, j + 1); + } + } + } + return arr[start + len / 2]; + } + + // Divide into groups of 5 + int num_groups = (len + 4) / 5; // ceiling division + int * medians = (int *)malloc(sizeof(int) * num_groups); + + for (int i = 0; i < num_groups; i++){ + int sub_start = start + i * 5; + // Last group may have fewer than 5 elements + int sub_stop = (sub_start + 4 > stop) ? stop : sub_start + 4; + int sub_len = sub_stop - sub_start + 1; + + // Sort this group + for (int j = sub_start; j <= sub_stop; j++){ + for (int k = sub_start; k < sub_stop - (j - sub_start); k++){ + if (arr[k] > arr[k + 1]){ + swap(arr, k, k + 1); + } + } + } + medians[i] = arr[sub_start + sub_len / 2]; // store median of this group + } + + // Recursively find the median of all medians + int result = median_of_medians_helper(medians, 0, num_groups - 1); + free(medians); + return result; +} + +/** + * @brief Recursive helper for median-of-medians algorithm + * @details + * This function implements the same median-of-medians logic as the parent function. + * It's separated as a helper to manage recursion properly without modifying the original array unexpectedly. + * @param arr Pointer to the array + * @param start Starting index of the range + * @param stop Ending index of the range + * @returns The median value + */ +int median_of_medians_helper(int * arr, int start, int stop){ + int len = stop - start + 1; + if (len <= 5){ + for (int i = start; i <= stop; i++){ + for (int j = start; j < stop - (i - start); j++){ + if (arr[j] > arr[j + 1]){ + swap(arr, j, j + 1); + } + } + } + return arr[start + len / 2]; + } + + int num_groups = (len + 4) / 5; + int * medians = (int *)malloc(sizeof(int) * num_groups); + + for (int i = 0; i < num_groups; i++){ + int sub_start = start + i * 5; + int sub_stop = (sub_start + 4 > stop) ? stop : sub_start + 4; + int sub_len = sub_stop - sub_start + 1; + + for (int j = sub_start; j <= sub_stop; j++){ + for (int k = sub_start; k < sub_stop - (j - sub_start); k++){ + if (arr[k] > arr[k + 1]){ + swap(arr, k, k + 1); + } + } + } + medians[i] = arr[sub_start + sub_len / 2]; + } + + int result = median_of_medians_helper(medians, 0, num_groups - 1); + free(medians); + return result; +} + +/** + * @brief Finds the kth largest element in an array + * @details + * Uses the median-of-medians algorithm to find a good pivot, then partitions + * the array and recursively searches the appropriate half. The pivot selection + * guarantees O(n) time complexity in all cases (best, average, and worst). + * k is 1-based: k=1 returns the largest, k=2 returns the 2nd largest, etc. + * @param arr Pointer to the array + * @param k The rank to find (1 = largest, 2 = 2nd largest, ..., n = smallest) + * @param start Starting index of the search range + * @param stop Ending index of the search range + * @returns The kth largest element, or -1 if the range is invalid + */ +int kth_largest(int * arr, int k, int start, int stop){ + if (start > stop) return -1; + + // Use median-of-medians to pick a good pivot + int pivot_value = median_of_medians(arr, start, stop); + + // Partition: larger elements go left, smaller go right of partition + int pivot_index = partition(arr, start, stop, pivot_value); + // Rank = how many elements are >= pivot_value + int rank = pivot_index - start + 1; + + // Check if we found the answer + if (rank == k){ + return pivot_value; + } + // Kth largest is in left half (larger elements) + else if (rank > k){ + return kth_largest(arr, k, start, pivot_index - 1); + } + // Kth largest is in right half (smaller elements), adjust k by how many are seen + else{ + return kth_largest(arr, k - rank, pivot_index + 1, stop); + } +} + + +/** + * @brief Test cases + */ +static void test() { + // Test 1: Simple unsorted array, find 3rd largest (17) + int arr1[] = {7, 1, 15, 3, 19, 11, 5, 18, 2, 14, 9, 4, 16, 8, 12, 6, 17, 10, 13}; + int result1 = kth_largest(arr1, 3, 0, 18); + assert(result1 == 17); + printf("Test 1 passed: 3rd largest in unsorted array is 17\n"); + + // Test 2: Find the largest element (k=1) + int arr2[] = {5, 2, 8, 1, 9, 3}; + int result2 = kth_largest(arr2, 1, 0, 5); + assert(result2 == 9); + printf("Test 2 passed: 1st largest (max) is 9\n"); + + // Test 3: Find the smallest element (k=n) + int arr3[] = {5, 2, 8, 1, 9, 3}; + int result3 = kth_largest(arr3, 6, 0, 5); + assert(result3 == 1); + printf("Test 3 passed: 6th largest (min) in 6-element array is 1\n"); + + // Test 4: Single element array + int arr4[] = {42}; + int result4 = kth_largest(arr4, 1, 0, 0); + assert(result4 == 42); + printf("Test 4 passed: 1st largest in single-element array is 42\n"); + + // Test 5: Two elements, find largest + int arr5[] = {10, 20}; + int result5 = kth_largest(arr5, 1, 0, 1); + assert(result5 == 20); + printf("Test 5 passed: 1st largest in two-element array is 20\n"); + + // Test 6: Two elements, find smallest + int arr6[] = {10, 20}; + int result6 = kth_largest(arr6, 2, 0, 1); + assert(result6 == 10); + printf("Test 6 passed: 2nd largest in two-element array is 10\n"); + + // Test 7: Array with duplicates, find 4th largest + int arr7[] = {5, 3, 5, 2, 5, 1, 5}; + int result7 = kth_largest(arr7, 4, 0, 6); + assert(result7 == 5); // sorted desc: [5,5,5,5,3,2,1], 4th is 5 + printf("Test 7 passed: 4th largest with duplicates is 5\n"); + + // Test 8: Already sorted (descending), find middle + int arr8[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; + int result8 = kth_largest(arr8, 5, 0, 9); + assert(result8 == 6); + printf("Test 8 passed: 5th largest in sorted descending array is 6\n"); + + // Test 9: Already sorted (ascending), find 3rd largest + int arr9[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int result9 = kth_largest(arr9, 3, 0, 9); + assert(result9 == 8); + printf("Test 9 passed: 3rd largest in sorted ascending array is 8\n"); + + // Test 10: Larger array with random values + int arr10[] = {45, 23, 78, 12, 89, 34, 56, 90, 67, 21, 98, 54, 32, 11, 88, 77, 42}; + int result10 = kth_largest(arr10, 5, 0, 16); + assert(result10 == 78); // 5th largest: 98, 90, 89, 88, 78 + printf("Test 10 passed: 5th largest in random array is 78\n"); + + printf("\nAll tests have successfully passed!\n"); +} + +// Main Function +int main(){ + test(); + return 0; +}