up reference quick sort implement - review and manual implement later!

Author: sangtrandev00

src/algorithm/sorting/merge-sort.ts

@@ -1,7 +1,8 @@
 const numbers = [99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0];
 
+
 export function mergeSort(array: number[]): number[] {
-    // Stop point
+    // Stop point (case)
     if (array.length <= 1) {
         return array
     }
@@ -11,10 +12,13 @@ export function mergeSort(array: number[]): number[] {
     const middle = Math.floor(length / 2);
     const left = array.slice(0, middle)
     const right = array.slice(middle)
+    console.log("left", left);
+    console.log("right", right)
 
-    // Recursive point
+    // Recursive point (recursive case)
+    // Mỗi lần merge thì mất n 
     return merge(
-        mergeSort(left),
+        mergeSort(left), // Chia đôi chiều dài của mảng để mảng đạt 1 phần tử tốn logN thời gian (logN lần lặp => Ví dụ mảng có 256 phần tử => Tốn log256 => tốn 8 lần chạy của hàm )
         mergeSort(right)
     )
 }
@@ -40,6 +44,7 @@ export function merge(left: number[], right: number[]) {
             rightIndex++;
         }
     }
+    console.log(left, right);
 
     return result.concat(left.slice(leftIndex)).concat(right.slice(rightIndex));
 }

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

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "bun:test";
+import { quickSort } from "./quick-sort";
+
+describe('Quick Sort Function', () => {
+    it('should sort an unsorted array', () => {
+        const unsortedArray = [99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0];
+        const result = quickSort(unsortedArray, 0, unsortedArray.length - 1);
+        expect(result).toEqual([0, 1, 2, 4, 5, 6, 44, 63, 87, 99, 283]);
+    });
+
+    it('should handle an already sorted array', () => {
+        const sortedArray = [0, 1, 2, 4, 5, 6, 44, 63, 87, 99, 283];
+        const result = quickSort(sortedArray, 0, sortedArray.length - 1);
+        expect(result).toEqual(sortedArray);
+    });
+
+    it('should handle an empty array', () => {
+        const result = quickSort([], 0, -1);
+        expect(result).toEqual([]);
+    });
+
+    it('should handle an array with one element', () => {
+        const result = quickSort([42], 0, 0);
+        expect(result).toEqual([42]);
+    });
+
+    it('should handle an array with duplicate elements', () => {
+        const result = quickSort([3, 1, 2, 3, 3, 0], 0, 5);
+        expect(result).toEqual([0, 1, 2, 3, 3, 3]);
+    });
+
+    it('should handle an array with negative numbers', () => {
+        const result = quickSort([-3, -1, 0, -2, 1, 2], 0, 5);
+        expect(result).toEqual([-3, -2, -1, 0, 1, 2]);
+    });
+});

src/algorithm/sorting/quick-sort.ts

@@ -0,0 +1,54 @@
+const numbers = [99, 44, 6, 2, 1, 5, 63, 87, 283, 4, 0];
+// Chọn pivot 99
+// Lần 1: 99 với 0 => swap 0 với 99 => [0, 99, 44, 6, 2, 1, 5, 63, 87, 283, 4]
+// Lần 2: 99 với 4 => swap 4 với 99 => [0, 4, 99, 44, 6, 2, 1, 5, 63, 87, 283]
+// Lần 3: 99 với 283 => Không thể swap
+// Lần 4: 99 với 87 => Swap 87 với 99 => [0, 4, 87, 99, 44, 6, 2, 1, 5, 63, 283]
+// Lần 5: 99 với 63 => Swap 63 với 99 => [0, 4, 87, 63, 99, 44, 6, 2, 1, 5, 283]
+// ...
+// Lần thứ n: 99 với .. => Swap  với 99 => [0, 4, 87, 63, 5, 99, 44, 6, 2, 1, 283]
+// Lần thứ n: 99 với .. => Swap  với 99 => [0, 4, 87, 63, 5, 1, 99, 44, 6, 2, 283]
+// Lần thứ n: 99 với .. => Swap  với 99 => [0, 4, 87, 63, 5, 1, 2, 99, 44, 6, 283]
+// Lần thứ n: 99 với .. => Swap  với 99 => [0, 4, 87, 63, 5, 1, 2, 6, 44, 99 , 283]
+
+
+export function quickSort(array: number[], left: number, right: number) {
+    // Đây chỉ là tham khảo thôi!
+    let pivot;
+    let partitionIndex: number;
+
+    if (left < right) {
+        pivot = right;
+        partitionIndex = partition(array, pivot, left, right);
+
+        //sort left and right
+        quickSort(array, left, partitionIndex - 1);
+        quickSort(array, partitionIndex + 1, right);
+    }
+    return array;
+
+}
+
+function partition(array: number[], pivot: number, left: number, right: number): number {
+    let pivotValue = array[pivot];
+    let partitionIndex = left;
+
+    for (let i = left; i < right; i++) {
+        if (array[i] < pivotValue) {
+            swap(array, i, partitionIndex);
+            partitionIndex++;
+        }
+    }
+    swap(array, right, partitionIndex);
+    return partitionIndex;
+}
+
+function swap(array: number[], firstIndex: number, secondIndex: number) {
+    var temp = array[firstIndex];
+    array[firstIndex] = array[secondIndex];
+    array[secondIndex] = temp;
+}
+
+//Select first and last index as 2nd and 3rd parameters
+quickSort(numbers, 0, numbers.length - 1);
+console.log(numbers);