sort-n-search 1.0.1 → 1.0.3

package/index.js

@@ -1,3 +1 @@
-// Групповые экспорты
-export * from './src/sorting/index.js';
-export * from './src/searching/index.js';
+export { AlgorithmFactory } from "./src/factory/AlgorithmFactory.js"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sort-n-search",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Библиотека алгоритмов сортировки и поиска на Node.js",
   "license": "ISC",
   "author": "Матвей Оспищев",

package/src/factory/AlgorithmFactory.js

@@ -0,0 +1,47 @@
+import { BubbleSort } from "../sorting/BubbleSort.js";
+import { InsertSort } from "../sorting/InsertSort.js";
+import { MergeSort } from "../sorting/MergeSort.js";
+import { QuickSort } from "../sorting/QuickSort.js";
+import { SelectSort } from "../sorting/SelectSort.js";
+import { LinearSearch } from "../searching/LinearSearch.js";
+import { BinarySearch } from "../searching/BinarySearch.js";
+
+export class AlgorithmFactory {
+
+    static getSorter(type) {
+
+        switch (type) {
+            case "bubble":
+                return new BubbleSort();
+
+            case "insert":
+                return new InsertSort();
+
+            case "merge":
+                return new MergeSort();
+
+            case "quick":
+                return new QuickSort();
+            
+            case "select":
+                return new SelectSort();
+
+            default:
+                throw new Error("Неизвестный алгоритм сортировки");
+        }
+    }
+
+    static getSearcher(type) {
+
+        switch (type) {
+            case "linear":
+                return new LinearSearch();
+
+            case "binary":
+                return new BinarySearch();
+
+            default:
+                throw new Error("Неизвестный алгоритм поиска");
+        }
+    }
+}

package/src/searching/BinarySearch.js

@@ -0,0 +1,34 @@
+import { SearchStrategy } from "./SearchStrategy";
+
+/**
+ * Бинарный поиск (для отсортированных массивов)
+ * @param {number[]} array - отсортированный массив
+ * @param {number} target - целевое значение
+ * @returns {number} - индекс элемента или -1 если не найдено
+ * @time O(log n)
+ * @space O(1)
+ */
+export class BinarySearch extends SearchStrategy {
+  search(array, target) {
+    if (!Array.isArray(array)) {
+      throw new Error('Input must be an array');
+    }
+
+    let left = 0;
+    let right = array.length - 1;
+  
+    while (left <= right) {
+      const mid = Math.floor((left + right) / 2);
+
+      if (array[mid] === target) {
+        return mid;
+      } else if (array[mid] < target) {
+        left = mid + 1;
+      } else {
+        right = mid - 1;
+      }
+    }
+
+    return -1;
+  }
+}

package/src/searching/LinearSearch.js

@@ -0,0 +1,25 @@
+import { SearchStrategy } from "./SearchStrategy";
+
+/**
+ * Линейный поиск
+ * @param {number[]} array - массив для поиска
+ * @param {number} target - целевое значение
+ * @returns {number} - индекс элемента или -1 если не найдено
+ * @time O(n)
+ * @space O(1)
+ */
+export class LinearSearch extends SearchStrategy {
+  search(array, target) {
+    if (!Array.isArray(array)) {
+      throw new Error('Input must be an array');
+    }
+
+    for (let i = 0; i < array.length; i++) {
+      if (array[i] === target) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+}

package/src/searching/SearchStrategy.js

@@ -0,0 +1,5 @@
+export class SearchStrategy {
+    search(array, target) {
+        throw new Error("Method search() must be implemented");
+    }
+}

package/src/sorting/BubbleSort.js

@@ -0,0 +1,30 @@
+/**
+ * Сортировка пузырьком
+ * @param {number[]} array - массив для сортировки
+ * @returns {number[]} - отсортированный массив
+ * @time O(n²)
+ * @space O(1)
+ */
+
+import { SortStrategy } from "./SortStrategy"
+
+export class BubbleSort extends SortStrategy {
+  sort(array) {
+    if (!Array.isArray(array)) {
+      throw new Error('Input must be an array');
+    }
+  
+    const result = [...array];
+    const n = result.length;
+    
+    for (let i = 0; i < n - 1; i++) {
+      for (let j = 0; j < n - i - 1; j++) {
+        if (result[j] > result[j + 1]) {
+          [result[j], result[j + 1]] = [result[j + 1], result[j]];
+        }
+      }
+    }
+
+    return result;
+  }
+}

package/src/sorting/InsertSort.js

@@ -0,0 +1,26 @@
+import { SortStrategy } from "./SortStrategy";
+
+/**
+ * Сортировка вставками
+ * @param {number[]} array - массив для сортировки
+ * @returns {number[]} - отсортированный массив
+ * @time O(n) в лучшем случае, O(n²) в среднем и худшем
+ * @space O(1)
+ */
+export class InsertSort extends SortStrategy {
+    sort(array) {
+        for (let i = 1; i < array.length; i++) {
+            const current = array[i];
+            let j = i - 1;
+
+            while (j >= 0 && array[j] > current) {
+                array[j + 1] = array[j];
+                j--;
+            }
+
+            array[j + 1] = current;
+        }
+
+        return array;
+    }
+}

package/src/sorting/MergeSort.js

@@ -0,0 +1,41 @@
+import { SortStrategy } from "./SortStrategy";
+
+/**
+ * Сортировка слиянием
+ * @param {number[]} array - массив для сортировки
+ * @returns {number[]} - отсортированный массив
+ * @time O(n log n)
+ * @space O(n)
+ */
+export class MergeSort extends SortStrategy {
+  merge(left, right) {
+    const result = [];
+    let i = 0, j = 0;
+  
+    while (i < left.length && j < right.length) {
+      if (left[i] <= right[j]) {
+        result.push(left[i]);
+        i++;
+      } else {
+        result.push(right[j]);
+        j++;
+      }
+    }
+
+    return [...result, ...left.slice(i), ...right.slice(j)];
+  }
+
+  sort(array) {
+    if (!Array.isArray(array)) {
+      throw new Error('Input must be an array');
+    }
+  
+    if (array.length <= 1) return array;
+  
+    const mid = Math.floor(array.length / 2);
+    const left = this.sort(array.slice(0, mid));
+    const right = this.sort(array.slice(mid));
+    
+    return this.merge(left, right);
+  }
+}

package/src/sorting/QuickSort.js

@@ -0,0 +1,25 @@
+import { SortStrategy } from "./SortStrategy";
+
+/**
+ * Быстрая сортировка
+ * @param {number[]} array - массив для сортировки
+ * @returns {number[]} - отсортированный массив
+ * @time O(n log n) в среднем, O(n²) в худшем
+ * @space O(log n)
+ */
+export class QuickSort extends SortStrategy {
+  sort(array) {
+    if (!Array.isArray(array)) {
+      throw new Error('Input must be an array');
+    }
+
+    if (array.length <= 1) return array;
+
+    const pivot = array[Math.floor(array.length / 2)];
+    const left = array.filter(x => x < pivot);
+    const middle = array.filter(x => x === pivot);
+    const right = array.filter(x => x > pivot);
+
+    return [...this.sort(left), ...middle, ...this.sort(right)];
+  }
+}

package/src/sorting/SelectSort.js

@@ -0,0 +1,32 @@
+import { SortStrategy } from "./SortStrategy";
+
+/**
+ * Сортировка выбором
+ * @param {number[]} array - массив для сортировки
+ * @returns {number[]} - отсортированный массив
+ * @time O(n²) в лучшем, среднем и худшем случае
+ * @space O(1)
+ */
+export class SelectSort extends SortStrategy {
+    sort(array) {
+        if (!Array.isArray(array)) {
+            throw new Error('Input must be an array');
+        }
+
+        for (let i = 0; i < array.length - 1; i++) {
+            let minIndex = i;
+
+            for (let j = i + 1; j < array.length; j++) {
+                if (array[j] < array[minIndex]) {
+                    minIndex = j;
+                }
+            }
+
+            if (minIndex !== i) {
+                [array[i], array[minIndex]] = [array[minIndex], array[i]];
+            }
+        }
+
+        return array;
+    }
+}

package/src/sorting/SortStrategy.js

@@ -0,0 +1,5 @@
+export class SortStrategy {
+    sort(array) {
+        throw new Error("Method sort() must be implemented");
+    }
+}

package/src/tests/searching/BinarySearch.test.js

@@ -0,0 +1,25 @@
+import { BinarySearch } from "../../searching/BinarySearch"
+
+describe('BinarySearch', () => {
+  let searcher;
+
+  beforeEach(() => {
+    searcher = new BinarySearch();
+  });
+
+  test('находит элемент в отсортированном массиве', () => {
+    const array = [1, 3, 5, 7, 9, 11];
+
+    expect(searcher.search(array, 7)).toBe(3);
+  });
+
+  test('возвращает -1 если элемент не найден', () => {
+    const array = [1, 3, 5, 7, 9];
+
+    expect(searcher.search(array, 6)).toBe(-1);
+  });
+
+  test('обрабатывает пустой массив', () => {
+    expect(searcher.search([], 5)).toBe(-1);
+  });
+});

package/src/tests/searching/LinearSearch.test.js

@@ -0,0 +1,25 @@
+import { LinearSearch } from "../../searching/LinearSearch"
+
+describe('LinearSearch', () => {
+  let searcher;
+
+  beforeEach(() => {
+    searcher = new LinearSearch();
+  });
+
+  test('находит элемент в массиве', () => {
+    const array = [1, 3, 5, 7, 9, 11];
+
+    expect(searcher.search(array, 7)).toBe(3);
+  });
+
+  test('возвращает -1 если элемент не найден', () => {
+    const array = [1, 3, 5, 7, 9];
+
+    expect(searcher.search(array, 6)).toBe(-1);
+  });
+
+  test('обрабатывает пустой массив', () => {
+    expect(searcher.search([], 5)).toBe(-1);
+  });
+});

package/src/tests/sorting/BubbleSort.test.js

@@ -0,0 +1,24 @@
+import { BubbleSort } from "../../sorting/BubbleSort"
+
+describe('BubbleSort', () => {
+  let sorter;
+
+  beforeEach(() => {
+    sorter = new BubbleSort();
+  });
+
+  test('сортирует массив чисел правильно', () => {
+    const input = [5, 2, 8, 1, 9];
+    const expected = [1, 2, 5, 8, 9];
+
+    expect(sorter.sort(input)).toEqual(expected);
+  });
+
+  test('возвращает пустой массив для пустого входного', () => {
+    expect(sorter.sort([])).toEqual([]);
+  });
+
+  test('обрабатывает массив с одним элементом', () => {
+    expect(sorter.sort([42])).toEqual([42]);
+  });
+});

package/src/tests/sorting/InsertSort.test.js

@@ -0,0 +1,24 @@
+import { InsertSort } from "../../sorting/InsertSort"
+
+describe('InsertSort', () => {
+  let sorter;
+
+  beforeEach(() => {
+    sorter = new InsertSort();
+  });
+
+  test('сортирует массив чисел правильно', () => {
+    const input = [5, 2, 8, 1, 9];
+    const expected = [1, 2, 5, 8, 9];
+
+    expect(sorter.sort(input)).toEqual(expected);
+  });
+
+  test('возвращает пустой массив для пустого входного', () => {
+    expect(sorter.sort([])).toEqual([]);
+  });
+
+  test('обрабатывает массив с одним элементом', () => {
+    expect(sorter.sort([42])).toEqual([42]);
+  });
+});

package/src/tests/sorting/MergeSort.test.js

@@ -0,0 +1,24 @@
+import { MergeSort } from "../../sorting/MergeSort"
+
+describe('MergeSort', () => {
+  let sorter;
+
+  beforeEach(() => {
+    sorter = new MergeSort();
+  });
+
+  test('сортирует массив чисел правильно', () => {
+    const input = [5, 2, 8, 1, 9];
+    const expected = [1, 2, 5, 8, 9];
+
+    expect(sorter.sort(input)).toEqual(expected);
+  });
+
+  test('возвращает пустой массив для пустого входного', () => {
+    expect(sorter.sort([])).toEqual([]);
+  });
+
+  test('обрабатывает массив с одним элементом', () => {
+    expect(sorter.sort([42])).toEqual([42]);
+  });
+});

package/src/tests/sorting/QuickSort.test.js

@@ -0,0 +1,24 @@
+import { QuickSort } from "../../sorting/QuickSort"
+
+describe('QuickSort', () => {
+  let sorter;
+
+  beforeEach(() => {
+    sorter = new QuickSort();
+  });
+
+  test('сортирует массив чисел правильно', () => {
+    const input = [5, 2, 8, 1, 9];
+    const expected = [1, 2, 5, 8, 9];
+
+    expect(sorter.sort(input)).toEqual(expected);
+  });
+
+  test('возвращает пустой массив для пустого входного', () => {
+    expect(sorter.sort([])).toEqual([]);
+  });
+
+  test('обрабатывает массив с одним элементом', () => {
+    expect(sorter.sort([42])).toEqual([42]);
+  });
+});

package/src/tests/sorting/SelectSort.test.js

@@ -0,0 +1,24 @@
+import { SelectSort } from "../../sorting/SelectSort"
+
+describe('SelectSort', () => {
+  let sorter;
+
+  beforeEach(() => {
+    sorter = new SelectSort();
+  });
+
+  test('сортирует массив чисел правильно', () => {
+    const input = [5, 2, 8, 1, 9];
+    const expected = [1, 2, 5, 8, 9];
+
+    expect(sorter.sort(input)).toEqual(expected);
+  });
+
+  test('возвращает пустой массив для пустого входного', () => {
+    expect(sorter.sort([])).toEqual([]);
+  });
+
+  test('обрабатывает массив с одним элементом', () => {
+    expect(sorter.sort([42])).toEqual([42]);
+  });
+});

package/src/searching/binarySearch.js

@@ -1,30 +0,0 @@
-/**
- * Бинарный поиск (для отсортированных массивов)
- * @param {number[]} array - отсортированный массив
- * @param {number} target - целевое значение
- * @returns {number} - индекс элемента или -1 если не найдено
- * @time O(log n)
- * @space O(1)
- */
-export function binarySearch(array, target) {
-  if (!Array.isArray(array)) {
-    throw new Error('Input must be an array');
-  }
-  
-  let left = 0;
-  let right = array.length - 1;
-  
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    
-    if (array[mid] === target) {
-      return mid;
-    } else if (array[mid] < target) {
-      left = mid + 1;
-    } else {
-      right = mid - 1;
-    }
-  }
-  
-  return -1;
-}

package/src/searching/index.js

@@ -1,2 +0,0 @@
-export { linearSearch } from './linearSearch.js';
-export { binarySearch } from './binarySearch.js';

package/src/searching/linearSearch.js

@@ -1,21 +0,0 @@
-/**
- * Линейный поиск
- * @param {number[]} array - массив для поиска
- * @param {number} target - целевое значение
- * @returns {number} - индекс элемента или -1 если не найдено
- * @time O(n)
- * @space O(1)
- */
-export function linearSearch(array, target) {
-  if (!Array.isArray(array)) {
-    throw new Error('Input must be an array');
-  }
-  
-  for (let i = 0; i < array.length; i++) {
-    if (array[i] === target) {
-      return i;
-    }
-  }
-  
-  return -1;
-}

package/src/sorting/bubbleSort.js

@@ -1,25 +0,0 @@
-/**
- * Сортировка пузырьком
- * @param {number[]} array - массив для сортировки
- * @returns {number[]} - отсортированный массив
- * @time O(n²)
- * @space O(1)
- */
-export function bubbleSort(array) {
-  if (!Array.isArray(array)) {
-    throw new Error('Input must be an array');
-  }
-  
-  const result = [...array];
-  const n = result.length;
-  
-  for (let i = 0; i < n - 1; i++) {
-    for (let j = 0; j < n - i - 1; j++) {
-      if (result[j] > result[j + 1]) {
-        [result[j], result[j + 1]] = [result[j + 1], result[j]];
-      }
-    }
-  }
-  
-  return result;
-}

package/src/sorting/index.js

@@ -1,3 +0,0 @@
-export { bubbleSort } from './bubbleSort.js';
-export { quickSort } from './quickSort.js';
-export { mergeSort } from './mergeSort.js';

package/src/sorting/mergeSort.js

@@ -1,37 +0,0 @@
-/**
- * Сортировка слиянием
- * @param {number[]} array - массив для сортировки
- * @returns {number[]} - отсортированный массив
- * @time O(n log n)
- * @space O(n)
- */
-export function mergeSort(array) {
-  if (!Array.isArray(array)) {
-    throw new Error('Input must be an array');
-  }
-  
-  if (array.length <= 1) return array;
-  
-  const mid = Math.floor(array.length / 2);
-  const left = mergeSort(array.slice(0, mid));
-  const right = mergeSort(array.slice(mid));
-  
-  return merge(left, right);
-}
-
-function merge(left, right) {
-  const result = [];
-  let i = 0, j = 0;
-  
-  while (i < left.length && j < right.length) {
-    if (left[i] <= right[j]) {
-      result.push(left[i]);
-      i++;
-    } else {
-      result.push(right[j]);
-      j++;
-    }
-  }
-  
-  return [...result, ...left.slice(i), ...right.slice(j)];
-}

package/src/sorting/quickSort.js

@@ -1,21 +0,0 @@
-/**
- * Быстрая сортировка
- * @param {number[]} array - массив для сортировки
- * @returns {number[]} - отсортированный массив
- * @time O(n log n) в среднем, O(n²) в худшем
- * @space O(log n)
- */
-export function quickSort(array) {
-  if (!Array.isArray(array)) {
-    throw new Error('Input must be an array');
-  }
-  
-  if (array.length <= 1) return array;
-  
-  const pivot = array[Math.floor(array.length / 2)];
-  const left = array.filter(x => x < pivot);
-  const middle = array.filter(x => x === pivot);
-  const right = array.filter(x => x > pivot);
-  
-  return [...quickSort(left), ...middle, ...quickSort(right)];
-}

package/src/tests/searching/binarySearch.test.js

@@ -1,17 +0,0 @@
-import { binarySearch } from '../../searching/binarySearch';
-
-describe('binarySearch', () => {
-  test('находит элемент в отсортированном массиве', () => {
-    const array = [1, 3, 5, 7, 9, 11];
-    expect(binarySearch(array, 7)).toBe(3);
-  });
-  
-  test('возвращает -1 если элемент не найден', () => {
-    const array = [1, 3, 5, 7, 9];
-    expect(binarySearch(array, 6)).toBe(-1);
-  });
-  
-  test('обрабатывает пустой массив', () => {
-    expect(binarySearch([], 5)).toBe(-1);
-  });
-});

package/src/tests/searching/linearSearch.test.js

@@ -1,17 +0,0 @@
-import { linearSearch } from '../../searching/linearSearch';
-
-describe('linearSearch', () => {
-  test('находит элемент в отсортированном массиве', () => {
-    const array = [1, 3, 5, 7, 9, 11];
-    expect(linearSearch(array, 7)).toBe(3);
-  });
-  
-  test('возвращает -1 если элемент не найден', () => {
-    const array = [1, 3, 5, 7, 9];
-    expect(linearSearch(array, 6)).toBe(-1);
-  });
-  
-  test('обрабатывает пустой массив', () => {
-    expect(linearSearch([], 5)).toBe(-1);
-  });
-});

package/src/tests/sorting/bubbleSort.test.js

@@ -1,21 +0,0 @@
-import { bubbleSort } from '../../sorting/bubbleSort';
-
-describe('bubbleSort', () => {
-  test('сортирует массив чисел правильно', () => {
-    const input = [5, 2, 8, 1, 9];
-    const expected = [1, 2, 5, 8, 9];
-    expect(bubbleSort(input)).toEqual(expected);
-  });
-  
-  test('возвращает пустой массив для пустого входного', () => {
-    expect(bubbleSort([])).toEqual([]);
-  });
-  
-  test('обрабатывает массив с одним элементом', () => {
-    expect(bubbleSort([42])).toEqual([42]);
-  });
-  
-  test('вызывает ошибку для не-массива', () => {
-    expect(() => bubbleSort('not array')).toThrow('Input must be an array');
-  });
-});

package/src/tests/sorting/mergeSort.test.js

@@ -1,21 +0,0 @@
-import { mergeSort } from '../../sorting/mergeSort';
-
-describe('mergeSort', () => {
-  test('сортирует массив чисел правильно', () => {
-    const input = [5, 2, 8, 1, 9];
-    const expected = [1, 2, 5, 8, 9];
-    expect(mergeSort(input)).toEqual(expected);
-  });
-  
-  test('возвращает пустой массив для пустого входного', () => {
-    expect(mergeSort([])).toEqual([]);
-  });
-  
-  test('обрабатывает массив с одним элементом', () => {
-    expect(mergeSort([42])).toEqual([42]);
-  });
-  
-  test('вызывает ошибку для не-массива', () => {
-    expect(() => mergeSort('not array')).toThrow('Input must be an array');
-  });
-});

package/src/tests/sorting/quickSort.test.js

@@ -1,21 +0,0 @@
-import { quickSort } from '../../sorting/quickSort';
-
-describe('quickSort', () => {
-  test('сортирует массив чисел правильно', () => {
-    const input = [5, 2, 8, 1, 9];
-    const expected = [1, 2, 5, 8, 9];
-    expect(quickSort(input)).toEqual(expected);
-  });
-  
-  test('возвращает пустой массив для пустого входного', () => {
-    expect(quickSort([])).toEqual([]);
-  });
-  
-  test('обрабатывает массив с одним элементом', () => {
-    expect(quickSort([42])).toEqual([42]);
-  });
-  
-  test('вызывает ошибку для не-массива', () => {
-    expect(() => quickSort('not array')).toThrow('Input must be an array');
-  });
-});