Шпаргалки по алгоритмам

1. Структуры данных: сложность операций

2. Алгоритмы сортировки

Реализация быстрой сортировки (Quick Sort):

function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left < right) {
    const pivotIndex = partition(arr, left, right);
    quickSort(arr, left, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, right);
  }
  return arr;
}

function partition(arr, left, right) {
  const pivot = arr[right];
  let i = left - 1;
  
  for (let j = left; j < right; j++) {
    if (arr[j] <= pivot) {
      i++;
      [arr[i], arr[j]] = [arr[j], arr[i]];
    }
  }
  
  [arr[i + 1], arr[right]] = [arr[right], arr[i + 1]];
  return i + 1;
}

3. Алгоритмы поиска

Реализация бинарного поиска:

function binarySearch(arr, target) {
  let left = 0;
  let right = arr.length - 1;
  
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    
    if (arr[mid] === target) {
      return mid;
    } else if (arr[mid] < target) {
      left = mid + 1;
    } else {
      right = mid - 1;
    }
  }
  
  return -1; // Элемент не найден
}

4. Алгоритмы на графах

Алгоритм Дейкстры (реализация):

function dijkstra(graph, start) {
  const distances = {};
  const visited = {};
  const previous = {};
  const nodes = Object.keys(graph);
  
  // Инициализация
  for (let node of nodes) {
    distances[node] = Infinity;
    previous[node] = null;
  }
  distances[start] = 0;
  
  while (nodes.length) {
    // Находим узел с минимальным расстоянием
    nodes.sort((a, b) => distances[a] - distances[b]);
    const closest = nodes.shift();
    
    if (distances[closest] === Infinity) break;
    
    for (let neighbor in graph[closest]) {
      const distance = distances[closest] + graph[closest][neighbor];
      
      if (distance < distances[neighbor]) {
        distances[neighbor] = distance;
        previous[neighbor] = closest;
      }
    }
    
    visited[closest] = true;
  }
  
  return { distances, previous };
}

Пройди собеседование в топ-компанию

Платформа для подготовки

Решай алгоритмические задачи как профи

✓ Популярные алгоритмы✓ Разбор решений✓ AI помощь

Начать сейчас→

5. Динамическое программирование

Задача о рюкзаке (динамическое программирование):

function knapsack(weights, values, capacity) {
  const n = weights.length;
  const dp = Array(n + 1).fill().map(() => Array(capacity + 1).fill(0));
  
  for (let i = 1; i <= n; i++) {
    for (let w = 0; w <= capacity; w++) {
      if (weights[i - 1] <= w) {
        dp[i][w] = Math.max(
          values[i - 1] + dp[i - 1][w - weights[i - 1]],
          dp[i - 1][w]
        );
      } else {
        dp[i][w] = dp[i - 1][w];
      }
    }
  }
  
  return dp[n][capacity];
}

6. Строковые алгоритмы

Построение Z-функции:

function zFunction(s) {
  const n = s.length;
  const z = Array(n).fill(0);
  
  let left = 0, right = 0;
  for (let i = 1; i < n; i++) {
    if (i <= right) {
      z[i] = Math.min(right - i + 1, z[i - left]);
    }
    
    while (i + z[i] < n && s[z[i]] === s[i + z[i]]) {
      z[i]++;
    }
    
    if (i + z[i] - 1 > right) {
      left = i;
      right = i + z[i] - 1;
    }
  }
  
  return z;
}

7. Геометрические алгоритмы

Проверка, лежит ли точка внутри многоугольника:

function pointInPolygon(point, polygon) {
  const x = point[0], y = point[1];
  let inside = false;
  
  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
    const xi = polygon[i][0], yi = polygon[i][1];
    const xj = polygon[j][0], yj = polygon[j][1];
    
    const intersect = ((yi > y) !== (yj > y)) && 
                      (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
    if (intersect) inside = !inside;
  }
  
  return inside;
}

8. Криптографические алгоритмы

9. Алгоритмы машинного обучения

10. Практические советы по оптимизации

1. Выбор правильной структуры данных

   • Частый доступ по индексу? → Массив
   • Частые вставки/удаления? → Связный список
   • Быстрый поиск по ключу? → Hash Map
   • Диапазонные запросы? → Дерево отрезков

2. Оптимизация памяти

   • Используйте битовые операции для компактного хранения данных
   • Предварительное выделение памяти для массивов
   • Удаление ненужных промежуточных данных

3. Оптимизация времени

   • Предварительные вычисления (префиксные суммы и т.д.)
   • Использование кеширования (мемоизация в DP)
   • Избегайте лишних проходов по данным

4. Профилирование и отладка

   • Измерение времени работы критических участков
   • Нахождение узких мест в алгоритме
   • Пошаговая отладка для правильного понимания алгоритма