add: selection sort algorithm implementation

Author: EliasAfara

Sorting/SelectionSort.js

@@ -0,0 +1,42 @@
+import { swap } from "../Arrays/Swap";
+
+/**
+ * Sorts an array in ascending order using the Selection Sort algorithm.
+ *
+ * @param {number[]} arr - The input array to be sorted.
+ * @returns {number[]} - The sorted array.
+ *
+ * @description
+ * Selection Sort is a simple sorting algorithm that repeatedly selects the minimum element from the unsorted part of the array
+ * and places it at the beginning. The algorithm maintains two subarrays: one that is sorted and one that is unsorted.
+ *
+ * @complexity
+ * Time complexity:
+ * - Best-case time complexity: O(n^2) - In all cases, Selection Sort performs the same number of comparisons and swaps, resulting in a quadratic time complexity.
+ * - Average-case time complexity: O(n^2) - The algorithm's performance is similar for all cases, leading to a quadratic time complexity.
+ * - Worst-case time complexity: O(n^2) - Selection Sort always performs n*(n-1)/2 comparisons and n-1 swaps, resulting in a quadratic time complexity.
+ * Space complexity: O(1) - Constant space complexity, as the sorting is done in-place.
+ */
+function selectionSort(arr) {
+ const n = arr.length;
+
+ for (let i = 0; i < n - 1; i++) {
+ let minIndex = i;
+
+ // Find the index of the minimum element in the unsorted part of the array
+ for (let j = i + 1; j < n; j++) {
+ if (arr[j] < arr[minIndex]) {
+ minIndex = j;
+ }
+ }
+
+ // Swap the minimum element with the first element in the unsorted part
+ if (minIndex !== i) {
+ swap(arr, i, minIndex);
+ }
+ }
+
+ return arr;
+}
+
+export { selectionSort };

Sorting/tests/SelectionSort.test.js

@@ -0,0 +1,40 @@
+import { selectionSort } from "../SelectionSort";
+
+describe("selectionSort", () => {
+ it("should sort an array of integers in ascending order (best case)", () => {
+ const sortedArray = [1, 2, 3, 4, 5];
+ const result = selectionSort(sortedArray);
+
+ expect(result).toEqual(sortedArray);
+ });
+
+ it("should sort an array of integers in ascending order (average case)", () => {
+ const unsortedArray = [64, 25, 12, 22, 11];
+ const expectedArray = [11, 12, 22, 25, 64];
+ const sortedArray = selectionSort(unsortedArray);
+
+ expect(sortedArray).toEqual(expectedArray);
+ });
+
+ it("should sort an array of integers in ascending order (worst case)", () => {
+ const reverseSortedArray = [5, 4, 3, 2, 1];
+ const expectedArray = [1, 2, 3, 4, 5];
+ const sortedArray = selectionSort(reverseSortedArray);
+
+ expect(sortedArray).toEqual(expectedArray);
+ });
+
+ it("should handle an empty array", () => {
+ const emptyArray = [];
+ const sortedArray = selectionSort(emptyArray);
+
+ expect(sortedArray).toEqual([]);
+ });
+
+ it("should handle an array with a single element", () => {
+ const singleElementArray = [42];
+ const sortedArray = selectionSort(singleElementArray);
+
+ expect(sortedArray).toEqual([42]);
+ });
+});