Большой О записка

Большой О записью – это способ измерить эффективность алгоритма. Он измеряет время, необходимое для выполнения вашей функции по мере роста входа. Или, другими словами, насколько хорошо функциональный масштаб.

Например, у вас есть 10 чисел (2, 36, 5, 7, 3, 9, 0, 1, 10, 4), и вы хотите сортировать эти числа в последовательности. Как вы решите, какой алгоритм использовать? Что если есть 1000 номеров, то что вы будете делать? , Big O используется для измерения и найти наилучшее решение для такого типа проблем.

источник: https://www.bigocheatsheet.com/

O (log n)

Прежде чем понять, что такое O (log n), давайте поймем, что такое журнал или логарифмы. Логарифм – это сила, до которой должно быть поднято число, чтобы получить какое -то другое число. В информатике по умолчанию база журнала 2. Например, давайте возьмем номер 8. Основание 2 логарифм 8 составляет 3, потому что 2 поднята на силу 3 – 8: Короче говоря, мы просим Сколько 2 секунд необходимо умножить вместе, чтобы получить число Анкет Возвращаясь к O (log n), это в основном означает, Время идет линейно, в то время как n начинается в геометрической прогрессии Анкет Таким образом, если для вычисления 10 элементов потребуется 1 секунда, потребуется 2 секунды, чтобы вычислить 20 элементов, 3 секунды, чтобы вычислять 40 элементов и так далее. Примером алгоритма O (log n) будет алгоритм бинарного поиска:

function binarySearch(arr, val) {
  let upper = 0;
  let lower = arr.length - 1;

  while (upper <= lower) {
    let middle = Math.floor((upper + lower) / 2);

    if (arr[middle] === val) {
      // found the val
      return middle;
    } else if (arr[middle] < val) {
      // continue searching to the right
      upper = middle + 1;
    } else {
      // search searching to the left
      lower = middle - 1;
    }
  }
  // val wasn't found
  return -1;
}

//   Array should be sorted for binary search
let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

O (1)

Независимо от того, сколько предметов есть, будь то один миллион миллион, количество времени для завершения останется тем же. Например:

 const fishes = ["nemo", "marlin", "bruce", "crush", "dory"];

 function firstFishInLine(arr) {
   console.log(arr[0]); 
 }

Независимо от того, насколько велик массив, мы всегда будем захватывать первый предмет в массиве (мы делаем только одну вещь).

На)

В O (n) все петли являются примером линейного роста, потому что существует взаимосвязь один к одному между размером данных и временем до завершения. Таким образом, массив с на 100 раз больше предметов займет ровно на 100 раз дольше.

const fish = ["nemo", "marlin", "bruce", "crush", "dory"];

 function findingDorry(arr) {
   for (let i = 0; i <= arr.length; i++) {
     if (arr[i] === "dory") {
       console.log("🎉 Dory Found");
     }
   }
 }
 findingDorry(fish);

Больше рыб больше времени, которое потребуется, потому что он проверит каждый элемент в массиве.

O (n log n)

O (n log n) подразумевает, что log n Операции будут происходить n времена Например, поиск элемента в Сортированный список длины n o (log n) Анкет Поиск элемента в n разные сортированные списки, каждый из длина n – O (n log).

function nLogn(n) {
  let y = n;
  while (n > 1) {
    n = Math.floor(n / 2);           // O(log n)
    for (let i = 1; i <= y; i++) {   // O(n)
      console.log(i);
    }
  }
}

O (n^2)

O (n^2) чрезвычайно неэффективен. Это также может быть написано как O (n^x). Где x это количество вложенных петель. Поместить петлю в петлю – отличный способ превратить массив 1000 пунктов в миллион (1000 x 1000) операций, который заморозит ваш браузер. Любая форма вложенной петли является примером O (n^x). Ниже приведен пример O (n^2):

const fishes = ["nemo", "marlin", "bruce", "crush", "dory"];

function fishPairs(arr) {
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr.length; j++) {
      console.log(arr[i], arr[j]);
    }
  }
}

Разница между O (n^2) и O (2n)

Добавляем (+) для шагов в порядке (то есть: n+n)
А также Умножьте (*) для вложенных шагов (т.е.: n*n)

O (2^n)

O (2^n) обозначает алгоритм, рост которого удваивается, с каждым дополнением к набору входных данных. Кривая роста функции O (2^n) является экспоненциальной – начиная с очень мелкой, а затем поднимается метеорически. Отличным примером O (2^n) будет серия Fibonacci:

function fibonacci(num) {
   if (num <= 1) {
     return num;
   }
   return fibonacci(num - 2) + fibonacci(num - 1);
 }

На!)

O (n!) – одна из худших возможностей. Чтобы проиллюстрировать, как быстро взорвется факторные решения, стандартная колода карт имеет 52 карты, с 52! Возможные заказы карт после перетасовки. Это число больше, чем количество атомов на Земле. Один классический пример – Путешествие продавец Проблема с помощью грубого поиска. Если есть N городов, метод грубой силы будет пробовать каждую перестановку этих N городов, чтобы найти, какой из них самый дешевый. Теперь количество перестановки с N городами n! Сделать это факториал сложности (O (N!)).

Для простоты в наших примерах мы взяли только один тип массива или ввода, поэтому это n*n^2 или n+n Но разные входы должны иметь разные переменные. (Например, A*B или A+B)

Вы можете рассчитать Big O, выполнив эти 5 шагов:

Разбейте свой алгоритм/функцию на отдельные операции.
Рассчитайте большой O каждой операции.
Сложите большой O каждой операции вместе.
Удалите константы.
Определенные термины доминируют в других. O (1) . то есть игнорировать условия более низкого порядка. Найдите самый высокий уровень порядка – это будет то, что мы считаем большим O нашего алгоритма/функции.

Давайте попробуем рассчитать Big O по следующему примеру:

function foo(arr) {  
    let a = 30; // O(1) - only running once
    a = 1 + 3;  // O(1)

    for (let i = 0; i < arr.length; i++) { // O(n) - because it will run n:times
      someAnotherFunction(); // O(n) - Here we are calling some function. It will be called every time the loop is run. 
      let bool = true; // O(n) - again because inside for loop
      a++; // O(n)
    }
    return a; // O(1)
  }

Итак, Big O будет:

1 + 1 + n + n + n + n + + + 4n => o (3 + 4n)

Но давайте попробуем упростить его больше, посмотрим на правило «5 -е» выше. Определенные термины доминируют в других, (O (1) менее значимо, чем O (n)). Итак, мы отбросим счет 3 и теперь это будет O (4n) . В правиле «4 -е» мы определили, что мы должны удалить константы, поэтому окончательный ответ будет: На)

Оригинал: “https://dev.to/ankushdogradev/big-o-notation-3kf4”