Add basic algo sorting

Author: Ren0503

src/algorithms/sorting/Sort.js

@@ -0,0 +1,34 @@
+import Comparator from '../../utils/Comparator';
+
+/**
+ * @typedef {Object} SorterCallbacks
+ * @property {function(a: *, b: *)} compareCallback - Nếu được cung cấp, 
+ * thì tất cả phần tử sẽ được so sánh thông qua lệnh callback.
+ * @property {function(a: *)} visitingCallback - Nếu được cung cấp,
+ * thì nó sẽ được gọi mỗi khi hàm sắp xếp truy cập vào phần tử tiếp theo.
+ */
+
+export default class Sort {
+    constructor(originalCallbacks) {
+        this.callbacks = Sort.initSortingCallbacks(originalCallbacks);
+        this.comparator = new Comparator(this.callbacks.compareCallback);
+    }
+
+    /**
+     * @param {SorterCallbacks} originalCallbacks
+     * @returns {SorterCallbacks}
+     */
+    static initSortingCallbacks(originalCallbacks) {
+        const callbacks = originalCallbacks || {};
+        const stubCallback = () => { };
+
+        callbacks.compareCallback = callbacks.compareCallback || undefined;
+        callbacks.visitingCallback = callbacks.visitingCallback || stubCallback;
+
+        return callbacks;
+    }
+
+    sort() {
+        throw new Error('sort method must be implemented');
+    }
+}

src/algorithms/sorting/SortTester.js

@@ -0,0 +1,72 @@
+export const sortedArr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20];
+export const reverseArr = [20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1];
+export const notSortedArr = [15, 8, 5, 12, 10, 1, 16, 9, 11, 7, 20, 3, 2, 6, 17, 18, 4, 13, 14, 19];
+export const equalArr = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1];
+export const negativeArr = [-1, 0, 5, -10, 20, 13, -7, 3, 2, -3];
+export const negativeArrSorted = [-10, -7, -3, -1, 0, 2, 3, 5, 13, 20];
+
+export class SortTester {
+    static testSort(SortingClass) {
+        const sorter = new SortingClass();
+
+        expect(sorter.sort([])).toEqual([]);
+        expect(sorter.sort([1])).toEqual([1]);
+        expect(sorter.sort([1, 2])).toEqual([1, 2]);
+        expect(sorter.sort([2, 1])).toEqual([1, 2]);
+        expect(sorter.sort([3, 4, 2, 1, 0, 0, 4, 3, 4, 2])).toEqual([0, 0, 1, 2, 2, 3, 3, 4, 4, 4]);
+        expect(sorter.sort(sortedArr)).toEqual(sortedArr);
+        expect(sorter.sort(reverseArr)).toEqual(sortedArr);
+        expect(sorter.sort(notSortedArr)).toEqual(sortedArr);
+        expect(sorter.sort(equalArr)).toEqual(equalArr);
+    }
+
+    static testNegativeNumbersSort(SortingClass) {
+        const sorter = new SortingClass();
+        expect(sorter.sort(negativeArr)).toEqual(negativeArrSorted);
+    }
+
+    static testSortWithCustomComparator(SortingClass) {
+        const callbacks = {
+            compareCallback: (a, b) => {
+                if (a.length === b.length) {
+                    return 0;
+                }
+                return a.length < b.length ? -1 : 1;
+            },
+        };
+
+        const sorter = new SortingClass(callbacks);
+
+        expect(sorter.sort([''])).toEqual(['']);
+        expect(sorter.sort(['a'])).toEqual(['a']);
+        expect(sorter.sort(['aa', 'a'])).toEqual(['a', 'aa']);
+        expect(sorter.sort(['aa', 'q', 'bbbb', 'ccc'])).toEqual(['q', 'aa', 'ccc', 'bbbb']);
+        expect(sorter.sort(['aa', 'aa'])).toEqual(['aa', 'aa']);
+    }
+
+    static testSortStability(SortingClass) {
+        const callbacks = {
+            compareCallback: (a, b) => {
+                if (a.length === b.length) {
+                    return 0;
+                }
+                return a.length < b.length ? -1 : 1;
+            },
+        };
+
+        const sorter = new SortingClass(callbacks);
+
+        expect(sorter.sort(['bb', 'aa', 'c'])).toEqual(['c', 'bb', 'aa']);
+        expect(sorter.sort(['aa', 'q', 'a', 'bbbb', 'ccc'])).toEqual(['q', 'a', 'aa', 'ccc', 'bbbb']);
+    }
+
+    static testAlgorithmTimeComplexity(SortingClass, arrayToBeSorted, numberOfVisits) {
+        const visitingCallback = jest.fn();
+        const callbacks = { visitingCallback };
+        const sorter = new SortingClass(callbacks);
+
+        sorter.sort(arrayToBeSorted);
+
+        expect(visitingCallback).toHaveBeenCalledTimes(numberOfVisits);
+    }
+}

src/algorithms/sorting/bubble-sort/BubbleSort.js

@@ -0,0 +1,37 @@
+import Sort from '../Sort';
+
+export default class BubbleSort extends Sort {
+    sort(originalArray) {
+        // Gắn cờ lưu giữ thông tin về việc hoán đổi có xảy ra hay không.
+        let swapped = false;
+        // Sao chép mảng ban đầu để tránh việc thay đổi nó.
+        const array = [...originalArray];
+
+        for (let i = 1; i < array.length; i += 1) {
+            swapped = false;
+
+            // Gọi hàm callback.
+            this.callbacks.visitingCallback(array[i]);
+
+            for (let j = 0; j < array.length - i; j += 1) {
+                // Gọi hàm callback.
+                this.callbacks.visitingCallback(array[j]);
+
+                // Hoán đổi phần tử nếu nó sai thứ tự.
+                if (this.comparator.lessThan(array[j + 1], array[j])) {
+                    [array[j], array[j + 1]] = [array[j + 1], array[j]];
+
+                    // Đánh dấu đã đổi.
+                    swapped = true;
+                }
+            }
+
+            // Nếu không có hoán đổi thì mảng đã được sắp xếp và không cần tiếp tục.
+            if (!swapped) {
+                return array;
+            }
+        }
+
+        return array;
+    }
+}

src/algorithms/sorting/bubble-sort/README.md

@@ -0,0 +1,16 @@
+# Sắp xếp nổi bọt
+
+Sắp xếp nổi bọt là một thuật toán sắp xếp đơn giản bằng việc lặp đi lặp các bước so sánh các phần tử liền kề và hoán đổi chúng nếu chúng không theo đúng thứ tự (sắp xếp tăng dần hoặc giảm dần). Các hành động này được lặp lại cho đến khi không cần phải hoán đổi nữa, tức là lúc này danh sách đã được sắp xếp. 
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
+
+## Độ phức tạp
+
+| Name                  | Best            | Average             | Worst               | Memory    | Stable    | Comments  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Bubble sort**       | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Yes       |           |
+
+## Liên kết
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Bubble_sort)
+- [YouTube](https://www.youtube.com/watch?v=6Gv8vg0kcHc&index=27&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

src/algorithms/sorting/counting-sort/CountingSort.js

@@ -0,0 +1,78 @@
+import Sort from '../Sort';
+
+export default class CountingSort extends Sort {
+    /**
+     * @param {number[]} originalArray
+     * @param {number} [smallestElement]
+     * @param {number} [biggestElement]
+     */
+    sort(originalArray, smallestElement = undefined, biggestElement = undefined) {
+        // Khởi tạo phần tử lớn nhất và nhỏ nhất trong mảng để xây dựng mảng bucker số sau này.
+        let detectedSmallestElement = smallestElement || 0;
+        let detectedBiggestElement = biggestElement || 0;
+
+        if (smallestElement === undefined || biggestElement === undefined) {
+            originalArray.forEach((element) => {
+                // Truy cập phần tử.
+                this.callbacks.visitingCallback(element);
+
+                // Phát hiện phần tử lớn nhất.
+                if (this.comparator.greaterThan(element, detectedBiggestElement)) {
+                    detectedBiggestElement = element;
+                }
+
+                // Phát hiện phần tử nhỏ nhất.
+                if (this.comparator.lessThan(element, detectedSmallestElement)) {
+                    detectedSmallestElement = element;
+                }
+            });
+        }
+
+        // Khởi tạo mảng bucket.
+        // Mảng này sẽ giữ tần suất của mỗi số từ originalArray.
+        const buckets = Array(detectedBiggestElement - detectedSmallestElement + 1).fill(0);
+
+        originalArray.forEach((element) => {
+            // Truy cập phần tử.
+            this.callbacks.visitingCallback(element);
+
+            buckets[element - detectedSmallestElement] += 1;
+        });
+
+        // Add previous frequencies to the current one for each number in bucket
+        // to detect how many numbers less then current one should be standing to
+        // the left of current one.
+        for (let bucketIndex = 1; bucketIndex < buckets.length; bucketIndex += 1) {
+            buckets[bucketIndex] += buckets[bucketIndex - 1];
+        }
+
+        // Now let's shift frequencies to the right so that they show correct numbers.
+        // I.e. if we won't shift right than the value of buckets[5] will display how many
+        // elements less than 5 should be placed to the left of 5 in sorted array
+        // INCLUDING 5th. After shifting though this number will not include 5th anymore.
+        buckets.pop();
+        buckets.unshift(0);
+
+        // Now let's assemble sorted array.
+        const sortedArray = Array(originalArray.length).fill(null);
+        for (let elementIndex = 0; elementIndex < originalArray.length; elementIndex += 1) {
+            // Get the element that we want to put into correct sorted position.
+            const element = originalArray[elementIndex];
+
+            // Visit element.
+            this.callbacks.visitingCallback(element);
+
+            // Get correct position of this element in sorted array.
+            const elementSortedPosition = buckets[element - detectedSmallestElement];
+
+            // Put element into correct position in sorted array.
+            sortedArray[elementSortedPosition] = element;
+
+            // Increase position of current element in the bucket for future correct placements.
+            buckets[element - detectedSmallestElement] += 1;
+        }
+
+        // Return sorted array.
+        return sortedArray;
+    }
+}

src/algorithms/sorting/counting-sort/README.md

@@ -0,0 +1,30 @@
+import Sort from '../Sort';
+import MinHeap from '../../../data-structures/heap/MinHeap';
+
+export default class HeapSort extends Sort {
+    sort(originalArray) {
+        const sortedArray = [];
+        const minHeap = new MinHeap(this.callbacks.compareCallback);
+
+        // Chèn tất cả phần tử trong mảng vào heap.
+        originalArray.forEach((element) => {
+            // Gọi hàm callback.
+            this.callbacks.visitingCallback(element);
+
+            minHeap.add(element);
+        });
+
+        // Giờ ta có min heap với phần tử nhỏ nhất luôn ở trên cùng.
+        // Kiểm tra vòng từng phần tử cực tiểu và tạo thành mảng đã sắp xếp.
+        while (!minHeap.isEmpty()) {
+            const nextMinElement = minHeap.poll();
+
+            // Gọi hàm callback.
+            this.callbacks.visitingCallback(nextMinElement);
+
+            sortedArray.push(nextMinElement);
+        }
+
+        return sortedArray;
+    }
+}

src/algorithms/sorting/heap-sort/HeapSort.js

@@ -0,0 +1,18 @@
+# Sắp xếp vun đống
+
+Sắp xếp vun đống thuộc loại sắp xếp so sánh.
+Sắp xếp vun đống có thể coi là một cải tiến của sắp xếp chọn: nó chia đầu vào thành vùng đã sắp xếp và vùng chưa được sắp xếp, sau đó thu nhỏ vùng chưa sắp xếp bằng cách lấy phần tử lớn nhất và thêm nó vào mảng đã sắp xếp. Lặp đi lặp lại nhiều lần để có được mảng đã sắp xếp hoàn toàn. Cải tiến ở đây nằm ở việc sử dụng cấu trúc dữ liệu heap chứ vẫn là tìm kiếm giá trị lớn nhất theo thời gian tuyến tính.
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif)
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif)
+
+## Độ phức tạp
+
+| Name                  | Best            | Average             | Worst               | Memory    | Stable    | Comments  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Heap sort**         | n log(n)   | n log(n)       | n log(n)       | 1         | No        |           |
+
+## Liên kết
+
+[Wikipedia](https://en.wikipedia.org/wiki/Heapsort)

src/algorithms/sorting/heap-sort/README.md

@@ -0,0 +1,39 @@
+import Sort from '../Sort';
+
+export default class InsertionSort extends Sort {
+    sort(originalArray) {
+        const array = [...originalArray];
+
+        // Đi qua tất cả phần tử của mảng...
+        for (let i = 1; i < array.length; i += 1) {
+            let currentIndex = i;
+
+            // Gọi hàm callback.
+            this.callbacks.visitingCallback(array[i]);
+
+            // Kiểm tra xem phần tử trước đó có lớn hơn phần tử hiện tại hay không.
+            // Nếu có, hãy hoán đổi hai phần tử.
+            while (
+                array[currentIndex - 1] !== undefined
+                && this.comparator.lessThan(array[currentIndex], array[currentIndex - 1])
+            ) {
+                // Gọi hàm callback.
+                this.callbacks.visitingCallback(array[currentIndex - 1]);
+
+                // Hoán đổi phần tử.
+                [
+                    array[currentIndex - 1],
+                    array[currentIndex],
+                ] = [
+                        array[currentIndex],
+                        array[currentIndex - 1],
+                    ];
+
+                // Chuyển sang chỉ mục bên trái.
+                currentIndex -= 1;
+            }
+        }
+
+        return array;
+    }
+}

src/algorithms/sorting/insertion-sort/InsertionSort.js

@@ -0,0 +1,17 @@
+# Sắp xếp chèn
+
+Sắp xếp chèn là thuật toán sắp xếp đơn giản để xây dựng một mảng (danh sách) cuối cùng bằng việc thêm từng mục tại một thời điểm. Nó kém hiệu quả hơn nhiều trên các danh sách lớn so với các thuật toán nâng cao hơn như quicksort, heapsort hoặc merge sort.
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/4/42/Insertion_sort.gif)
+
+![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)
+
+## Độ phức tạp
+
+| Name                  | Best            | Average             | Worst               | Memory    | Stable    | Comments  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Insertion sort**    | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Yes       |           |
+
+## Liên kết
+
+[Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)