Во время моего последнего поста в блоге я говорил о конкретной проблеме, которая включена с использованием проверки 3 различных индексов для проверки состояния 3 разных чисел одновременно. Решение, которое я предложил в конечном итоге с помощью петли для петли для петли … в рамках цикла (я слышал, как для петлей). Давайте сделаем еще один взгляд на структуру проблемы:
function pythagoreanCheck(array){ for(i = 0; i < array.length - 2; i++){ for(j = i + 1; j < array.length - 1; i++){ for(k = j + 1; k < array.length; k++){ *condition for returning true* } } } }
Эта структура функции принимает массив и проверяет для каждой уникальной комбинации из 3 чисел. Как я уже упоминал ранее, это был чрезвычайно неэффективный способ решить проблему, даже думал, что это технически работает. Чтобы положить его в конкретные термины, способ поговорить о неэффективности проблемы называется большим обозначением.
«Обозначение» выглядит так: O (N)
O обозначает функцию, а n обозначает вход и как он масштабируется с нашей операцией. Вместе они стоят за время, необходимое для алгоритма для запуска до завершения.
Чтобы взглянуть на некоторые основные примеры для знакомства, операция, которая имеет a (1) время выполнения, было бы то, что делает одну функцию, независимо от того, какой размер ввода, поскольку нам дают постоянную. Это было бы нечто вроде базового журнала консоли или любая единственная операция. Размер входов был бы неактуальным для нашего времени выполнения.
Далее у нас есть o (n), который был бы время выполнения для одного для цикла. Мы можем представить, что если у нас есть цикл для цикла, который проходит через весь вход, наше время выполнения пропорционально размеру ввода. Размер n ввода дает нам время выполнения, которое пропорционально этому размеру ввода. Важная концепция, чтобы помнить здесь, так это то, что O (n) измеряет время выполнения пропорционально входу .
Если мы посмотрим на наш предыдущий пример, мы можем увидеть эту пропорцию в пьесе. Поскольку у нас есть 3 итерация, мы можем рассмотреть время выполнения операции, как растут до мощности 3 пропорционально первоначальному размеру ввода. Если бы у нас был ввод размер 100, мы получим время выполнения, которое придется запускать 100 операций на 100 операций каждого из 100 входов. Это будет иметь большой (O) обозначения O (N ^ 3). Это будет масштабировать до O (n ^ 2), если у вас была операция, которая имела только одну вложенную итерацию.
Мы рассмотрели время выполнения, когда появился ввод размера 100, потому что следующий момент, который мы рассмотрим, так это то, что нотация Big O ищет рост времени выполнения Как вход растет произвольно большой Отказ Изменение времени выполнения не ощущается между o (n) и o (n ^ 2) runtimes с входным размером 2, но он вырастает экспоненциально, когда мы изменяем это на размер 100 или 1000 входных данных. Это своего рода «худший сценарий», который мы хотим дифференцировать при разных операциях.
Чтобы покрыть эту тему немного больше, давайте рассмотрим этот пример:
let nums = [1,2,3,4,5,6,7,8,9,10] function twoLoops(nums){ for(let i = 0; i < nums.length; i++){ console.log(nums[i]) } for(let i = 0; i < nums.length; i++){ console.log(nums[i]) } }
У нас есть два для петлей, работающих в этой функции, но в этом примере они не вложены. В таком случае какое было бы нашему обозначению? Поскольку у нас есть для каждого ввода, две разные операции работают, мы должны технически получать o (2n) время выполнения. Тем не менее, одна вещь, которую нужно помнить о Big (o), заключается в том, что поскольку мы заботимся о том, что вход только в том, что вход становится произвольно крупным, кратные цифры фактически игнорируются. Если вы можете себе представить 100 входов для этой функции, это даст нам время выполнения «200», тогда как, если бы он был вложен в систему, он дал бы нам «10000». В свете этого множественное из 2 на самом деле незначительно. Итак, эта функция на самом деле O (n) время выполнения.
Это падение констант может быть применено к менее значительным терминам вообще. Например, если у вас была функция, подобная этому, обеспечивает еще один интересный случай:
let nums = [1,2,3,4,5,6,7,8,9,10] function anothaOne(nums){ for(let i = 0; i < nums.length; i++){ for(let j = 0; j < nums.length; j++ { console.log(nums[i], nums[j]) } } for(let i = 0; i < nums.length; i++){ console.log(nums[i]) } }
Эта функция предоставляет нам вложенное для петлей другой итерации рядом с этим. Это дает нам время выполнения O (N ^ 2 + N), но так же, как, например, как мы можем бросить константы, мы также можем отбросить менее значительный срок N, потому что, опять же, как функция растет произвольно большая, то становится незначительным для Остальное время выполнения.
Понимание больших нотаций O будет казаться незначительными на более ранних уровнях кодирования, но это очень актуальная проблема для приложений, которые занимаются большими уровнями ввода и использования этой информации, будет разница между пользователями приложений будет использоваться и не будет использовать. Для тех, кто хочет найти работу в программировании, это станет важной темой, чтобы понять процесс собеседования, а также на работе. Я ожидаю, что я буду продолжаться с большим количеством постов на этом с более конкретными примерами.
Оригинал: “https://dev.to/jihoshin28/big-o-notation-3ifb”