sort-n-search 1.0.0

package/README.md

@@ -0,0 +1,47 @@
+# sort-n-search
+
+Библиотека алгоритмов сортировки и поиска на Node.js.
+
+## Установка
+
+```bash
+npm install sort-n-search
+```
+
+## Использование
+
+```javascript
+import { 
+  bubbleSort, 
+  quickSort, 
+  mergeSort,
+  linearSearch, 
+  binarySearch 
+} from 'sort-n-search';
+
+## Алгоритмы
+
+### Сортировка
+
+| Алгоритм | Время (среднее) | Время (худшее) | Место |
+|----------|---------------|---------------|-------|
+| bubbleSort | O(n²) | O(n²) | O(1) |
+| quickSort | O(n log n) | O(n²) | O(log n) |
+| mergeSort | O(n log n) | O(n log n) | O(n) |
+
+### Поиск
+
+| Алгоритм | Время | Место | Требования |
+|----------|-------|-------|------------|
+| linearSearch | O(n) | O(1) | Nenhum |
+| binarySearch | O(log n) | O(1) | Отсортированный массив |
+
+## Тестирование
+
+```bash
+npm test
+```
+
+## Лицензия
+
+MIT

package/babel.config.cjs

@@ -0,0 +1,9 @@
+module.exports = {
+  presets: [
+    ['@babel/preset-env', {
+      targets: {
+        node: 'current'
+      }
+    }]
+  ]
+};

package/index.js

@@ -0,0 +1,3 @@
+// Групповые экспорты
+export * from './src/sorting/index.js';
+export * from './src/search/index.js';

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "sort-n-search",
+  "version": "1.0.0",
+  "description": "Библиотека алгоритмов сортировки и поиска на Node.js",
+  "license": "ISC",
+  "author": "Матвей Оспищев",
+  "type": "module",
+  "main": "index.js",
+  "public": true,
+  "scripts": {
+    "test": "jest"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "transform": {
+      "^.+\\.(js|jsx)$": "babel-jest"
+    }
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.29.7",
+    "babel-jest": "^30.4.1",
+    "jest": "^30.4.2"
+  }
+}

package/src/searching/binarySearch.js

@@ -0,0 +1,30 @@
+/**
+ * Бинарный поиск (для отсортированных массивов)
+ * @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

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

package/src/searching/linearSearch.js

@@ -0,0 +1,21 @@
+/**
+ * Линейный поиск
+ * @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

@@ -0,0 +1,25 @@
+/**
+ * Сортировка пузырьком
+ * @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

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

package/src/sorting/mergeSort.js

@@ -0,0 +1,37 @@
+/**
+ * Сортировка слиянием
+ * @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

@@ -0,0 +1,21 @@
+/**
+ * Быстрая сортировка
+ * @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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,21 @@
+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');
+  });
+});