feat: add quick select algorithm and test TheAlgorithms#6 (TheAlgorithms#140)

* feat: add quick select algorithm and test TheAlgorithms#6

* feat: update quick select algorithm and test TheAlgorithms#6

Author: prisojacques

sorts/quick_select.ts

@@ -0,0 +1,40 @@
+import {partition} from "./quick_sort";
+/**
+ * @function QuickSelect
+ * @description is an algorithm based on the QuickSort approach that selects the kth smallest element from an array
+ * @param {number[]} array - The array from which to select the element
+ * @param {number} k - The index representing the kth smallest element to find
+ * @param {number} left - The left boundary of the array or subarray to consider (default: 0)
+ * @param {number} right - The right boundary of the array or subarray to consider (default: array.length - 1)
+ * @returns {number} - The kth smallest element from the array
+ * @throws {Error} - If k is out of bounds (less than 0 or greater than or equal to array.length)
+ */
+
+export const QuickSelect = (
+    array: number[],
+    k: number,
+    left: number = 0,
+    right: number = array.length - 1
+):number => {
+    if(k < 0 || k >= array.length) {
+        throw new Error('k is out of bounds');
+    }
+    if (left === right) {
+        // If the list contains only one element, return that element
+        return array[left];
+    }
+
+    // Partition the array
+    let pivotIndex = partition(array, left, right);
+
+    // The pivot is in its final sorted position
+    if (k === pivotIndex) {
+        return array[k];
+    } else if (k < pivotIndex) {
+        // If k is less than the pivot index, look left
+        return QuickSelect(array, k, left, pivotIndex - 1);
+    } else {
+        // If k is greater than the pivot index, look right
+        return QuickSelect(array, k, pivotIndex + 1, right);
+    }
+};

sorts/test/quick_select.test.ts

@@ -0,0 +1,29 @@
+import { QuickSelect } from "../quick_select";
+
+describe('QuickSelect', () => {
+    test('should return the kth smallest element in an array', () => {
+        const array = [8, 3, 5, 1, 4, 2];
+        expect(QuickSelect(array, 0)).toBe(1);
+        expect(QuickSelect(array, 1)).toBe(2);
+        expect(QuickSelect(array, 2)).toBe(3);
+        expect(QuickSelect(array, 3)).toBe(4);
+        expect(QuickSelect(array, 4)).toBe(5);
+        expect(QuickSelect(array, 5)).toBe(8);
+    });
+
+    test('should work with arrays of size 1', () => {
+        const array = [4];
+        expect(QuickSelect(array, 0)).toBe(4);
+    });
+
+    test('should work with large arrays', () => {
+        const array = Array.from({length: 1000}, (_, i) => i + 1);
+        expect(QuickSelect(array, 499)).toBe(500);
+    });
+
+    test('should throw error when k is out of bounds', () => {
+        const array = [8, 3, 5, 1, 4, 2];
+        expect(() => QuickSelect(array, -1)).toThrow();
+        expect(() => QuickSelect(array, 6)).toThrow();
+    });
+});