up sorting algorithm insertion function

Author: sangtrandev00

src/algorithm/sorting/index.ts

@@ -1 +1,4 @@
-import { bubbleSort, bubbleSortV2 } from './bubble-sort';
+import { bubbleSort, bubbleSortV2 } from './bubble-sort';
+import { selectionSort, selectionSortCallback } from './selection-sort';
+
+export { bubbleSort, bubbleSortV2, selectionSort, selectionSortCallback };

src/algorithm/sorting/insertion-sort.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "bun:test";
+import { insertionSort, insertionSortCallback } from "./insertion-sort";
+
+describe('Insertion Sort Functions', () => {
+ const unsortedArray = [99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0];
+ const sortedArrayAsc = [0, 1, 2, 4, 5, 6, 44, 63, 87, 99, 283];
+ const sortedArrayDesc = [...sortedArrayAsc].reverse();
+
+ describe('insertionSort', () => {
+ it('should sort the array in ascending order', () => {
+ const result = insertionSort([...unsortedArray]); // Spread to avoid mutation
+ expect(result).toEqual(sortedArrayAsc);
+ });
+
+ it('should handle an already sorted array', () => {
+ const result = insertionSort([...sortedArrayAsc]);
+ expect(result).toEqual(sortedArrayAsc);
+ });
+
+ it('should handle an empty array', () => {
+ const result = insertionSort([]);
+ expect(result).toEqual([]);
+ });
+
+ it('should handle an array with one element', () => {
+ const result = insertionSort([42]);
+ expect(result).toEqual([42]);
+ });
+
+ it('should handle an array with duplicate elements', () => {
+ const result = insertionSort([3, 1, 2, 3, 3, 0]);
+ expect(result).toEqual([0, 1, 2, 3, 3, 3]);
+ });
+ });
+
+ describe('insertionSortCallback', () => {
+ it('should sort the array in ascending order using a callback', () => {
+ const result = insertionSortCallback([...unsortedArray], (a, b) => a - b);
+ expect(result).toEqual(sortedArrayAsc);
+ });
+
+ it('should sort the array in descending order using a callback', () => {
+ const result = insertionSortCallback([...unsortedArray], (a, b) => b - a);
+ expect(result).toEqual(sortedArrayDesc);
+ });
+
+ it('should handle an already sorted array in ascending order', () => {
+ const result = insertionSortCallback([...sortedArrayAsc], (a, b) => a - b);
+ expect(result).toEqual(sortedArrayAsc);
+ });
+
+ it('should handle an already sorted array in descending order', () => {
+ const result = insertionSortCallback([...sortedArrayDesc], (a, b) => b - a);
+ expect(result).toEqual(sortedArrayDesc);
+ });
+
+ it('should handle an empty array', () => {
+ const result = insertionSortCallback([], (a, b) => a - b);
+ expect(result).toEqual([]);
+ });
+
+ it('should handle an array with one element', () => {
+ const result = insertionSortCallback([42], (a, b) => a - b);
+ expect(result).toEqual([42]);
+ });
+
+ it('should handle an array with duplicate elements', () => {
+ const result = insertionSortCallback([3, 1, 2, 3, 3, 0], (a, b) => a - b);
+ expect(result).toEqual([0, 1, 2, 3, 3, 3]);
+ });
+ });
+});

src/algorithm/sorting/insertion-sort.ts

@@ -0,0 +1,39 @@
+const numbers = [99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0];
+
+export function insertionSort(array: number[]) {
+ //Code Here
+ const length = array.length
+ for (let i = 0; i < length; i++) {
+ for (let j = i; j >= 0; j--) {
+ // Trường hợp xấu nhất là lặp đến j = 0 => arrar[j - 1] là undefined => Vẫn đúng
+ if (array[j] < array[j - 1]) {
+ let temp = array[j]
+ array[j] = array[j - 1]
+ array[j - 1] = temp
+ } else {
+ break;
+ }
+ }
+ }
+ return array
+}
+
+export function insertionSortCallback(array: number[], callback: (a: number, b: number) => number) {
+ //Code Here
+ const length = array.length
+ for (let i = 0; i < length; i++) {
+ for (let j = i; j >= 0; j--) {
+ if (callback(array[j], array[j - 1]) < 0) {
+ let temp = array[j]
+ array[j] = array[j - 1]
+ array[j - 1] = temp
+ } else {
+ break;
+ }
+ }
+ }
+ return array
+}
+
+// console.log(insertionSort(numbers));
+console.log(insertionSortCallback(numbers, (a, b) => b - a));

src/algorithm/sorting/selection-sort.ts

@@ -14,9 +14,11 @@ export function selectionSort(array: number[]) {
  }
  }
  // Swap the found minimum element with the first element
- let temp = array[i]
- array[i] = minItem
- array[minIndex] = temp
+ if (i !== minIndex) {
+ let temp = array[i]
+ array[i] = minItem
+ array[minIndex] = temp
+ }
  }
  return array
 }