Що саме означає O (log n)?

Я дізнаюся про час роботи Big O Notation та амортизований час. Я розумію поняття O (n) лінійного часу, тобто розмір вхідного сигналу пропорційно впливає на ріст алгоритму ... і те саме стосується, наприклад, квадратичного часу O (n ² ) тощо. , таких як генератори перестановки, з O (n!) разів, які зростають на фабриках.

Наприклад, наступна функція - O (n), оскільки алгоритм зростає пропорційно вхідному n :

f(int n) {
  int i;
  for (i = 0; i < n; ++i)
    printf("%d", i);
}

Аналогічно, якби була вкладена петля, час був би O (n ² ).

Але що саме таке O (log n) ? Наприклад, що означає сказати, що висота повного двійкового дерева дорівнює O (log n) ?

Я точно знаю (можливо, не дуже докладно), що таке логарифм, в тому сенсі, що: log ₁₀ 100 = 2, але я не можу зрозуміти, як ідентифікувати функцію з логарифмічним часом.

Я не можу зрозуміти, як ідентифікувати функцію з часом входу.

Найпоширенішими атрибутами логарифмічної функції часу є:

• вибір наступного елемента, на якому потрібно виконати якусь дію, є однією з кількох можливостей, і
• потрібно буде вибрати лише одного.

або

• елементами, над якими виконується дія, є цифри n

Ось чому, наприклад, пошук людей у ​​телефонній книзі - це O (log n). Вам не потрібно перевіряти кожну людину в телефонній книзі, щоб знайти потрібну; натомість ви можете просто розділити і перемогти, дивлячись на те, де їх ім’я в алфавіті, і в кожному розділі вам потрібно лише вивчити підмножину кожного розділу, перш ніж ви нарешті знайдете чийсь номер телефону.

Звичайно, більша телефонна книга все одно займе у вас довший час, але вона не зростатиме так швидко, як пропорційне збільшення додаткового розміру.

Ми можемо розширити приклад телефонної книги для порівняння інших видів операцій та часу їх роботи. Ми припустимо, що в нашій телефонній книзі є підприємства ("Жовті сторінки"), які мають унікальні імена та люди ("Білі сторінки"), які можуть не мати унікальних назв. Номер телефону присвоюється щонайменше одній особі чи компанії. Ми також будемо вважати, що потрібен постійний час для перегортання певної сторінки.

Ось час деяких операцій, які ми можемо виконувати в телефонній книзі, від найшвидшого до найповільнішого:

• O (1) (в гіршому випадку): З огляду на сторінку, на якій вказано ім'я компанії, та назву компанії, знайдіть номер телефону.

• O (1) (в середньому випадку): Враховуючи сторінку, на якій вказано ім’я людини, та її ім'я, знайдіть номер телефону.

• O (журнал n): Враховуючи ім’я людини, знайдіть номер телефону, вибравши випадкову точку приблизно на півдорозі тієї частини книги, яку ви ще не шукали, а потім перевірте, чи є ім’я людини в цій точці. Потім повторіть процес приблизно на півдорозі через частину книги, де лежить ім’я людини. (Це двійковий пошук імені людини.)

• O (n): Знайдіть усіх людей, чиї номери телефонів містять цифру "5".

• O (n): надавши номер телефону, знайдіть особу чи компанію з цим номером.

• O (n журнал n): в офісі принтера відбулося змішання, і в нашій телефонній книзі всі його сторінки вставлені у випадковому порядку. Виправте замовлення таким чином, щоб воно було правильним, переглянувши ім’я на кожній сторінці, а потім поклавши його на відповідне місце у новій порожній телефонній книзі.

Для наведених нижче прикладів ми зараз в офісі принтера. Телефонні книги чекають, щоб їх відправили по електронній пошті кожному жителю чи компанії, і на кожній телефонній книзі є наклейка, яка визначає, куди її потрібно відправити. Кожна людина чи бізнес отримують одну телефонну книгу.

• O (n журнал n): Ми хочемо персоналізувати телефонну книгу, тому ми збираємось знайти ім’я кожної людини чи компанії в їх призначеній копії, потім обведемо їх ім’я в книзі та напишемо коротку подячну записку за їх заступництво .

• O (n ² ): в офісі сталася помилка, і кожен запис у кожній із телефонних книжок має додатковий "0" в кінці номера телефону. Візьміть кілька пробілів і видаліть кожен нуль.

• O (n · n!): Ми готові завантажити телефонні книги на транспортний док. На жаль, робот, який повинен був завантажувати книжки, пішов безпроблемно: він кладе книги на вантажівку у випадковому порядку! Ще гірше, що він завантажує всі книги на вантажівку, потім перевіряє, чи вони в правильному порядку, а якщо ні, то вивантажує їх і починає спочатку. (Це страшний вид бого .)

• O (n ⁿ ): Ви фіксуєте робота так, щоб він правильно завантажував речі. Наступного дня один із ваших колег грає на вас і розводить робота завантажувальної доки до автоматизованих систем друку. Кожен раз, коли робот іде на завантаження оригінальної книги, заводський принтер робить дублюючий запуск усіх телефонних книг! На щастя, системи виявлення помилок роботи є досить складними, що робот не намагається надрукувати ще більше копій, коли він стикається з дублікатами книги для завантаження, але він все одно повинен завантажувати кожну надруковану оригінальну та копію книги.

O(log N)в основному означає, що час іде лінійно вгору, тоді як nіде вгору експоненціально. Отже, якщо 1для обчислення 10елементів знадобиться друге, для обчислення елементів знадобиться 2секунди 100, 3для обчислення 1000елементів тощо.

Це O(log n)коли ми ділимо і перемагаємо тип алгоритмів, наприклад, двійковий пошук. Інший приклад - це швидке сортування, коли кожен раз ми ділимо масив на дві частини, і кожен раз потрібен O(N)час, щоб знайти зведений елемент. Звідси це N O(log N)

На це питання вже розміщено багато хороших відповідей, але я вважаю, що насправді не вистачає важливого, а саме - ілюстрованої відповіді.

Що означає говорити про те, що висота повного двійкового дерева дорівнює O (log n)?

На наступному малюнку зображено двійкове дерево. Зверніть увагу, як кожен рівень містить подвійну кількість вузлів порівняно з рівнем вище (отже, двійковий ):

Двійковий пошук - приклад зі складністю O(log n). Скажімо, вузли в нижньому рівні дерева на рисунку 1 представляють елементи в деякій сортованій колекції. Двійковий пошук - це алгоритм розділення і перемоги, і на кресленні показано, як нам знадобиться (максимум) 4 порівняння, щоб знайти запис, який ми шукаємо в цьому наборі даних 16 елементів.

Припустимо, у нас замість цього був набір даних із 32 елементами. Продовжуйте малюнок вище, щоб з’ясувати, що зараз нам знадобиться 5 порівнянь, щоб знайти те, що ми шукаємо, оскільки дерево зросло лише на один рівень глибше, коли ми примножили кількість даних. В результаті складність алгоритму можна охарактеризувати як логарифмічний порядок.

Накреслення log(n)на звичайному аркуші паперу призведе до появи графіка, де зростання кривої уповільнюється зі nзбільшенням:

Нижче пояснення - це використання випадку повністю збалансованого двійкового дерева, щоб допомогти вам зрозуміти, як ми отримуємо логарифмічну часову складність.

Бінарне дерево - це випадок, коли проблема розміру n ділиться на підпроблему розміру n / 2, поки ми не дійдемо до задачі розміру 1:

Ось так ви отримуєте O (log n), який є об’ємом роботи, яку потрібно виконати на вищезазначеному дереві, щоб досягти рішення.

Поширений алгоритм з часовою складністю O (log n) - це двійковий пошук, рекурсивне відношення якого T (n / 2) + O (1), тобто на кожному наступному рівні дерева ви розділите задачу навпіл і виконайте постійну кількість додаткової роботи.

Огляд

Інші наводили хороші приклади діаграм, наприклад, діаграми дерева. Я не бачив простих прикладів коду. Тож крім мого пояснення, я надам деякі алгоритми з простими твердженнями про друк, щоб проілюструвати складність різних категорій алгоритмів.

По-перше, вам захочеться мати загальне уявлення про логарифм, який ви можете отримати на веб-сайті https://en.wikipedia.org/wiki/Logarithm . Природознавство eта природний журнал. Учні-інженери використовуватимуть log_10 (журнал бази 10), а вчені-комп’ютери багато використовуватимуть log_2 (журнал бази 2), оскільки комп'ютери мають бінарну основу. Іноді ви бачите абревіатури природного журналу як ln(), інженери зазвичай залишають _10 вимкненим і просто використовують, log()а log_2 скорочується як lg(). Усі типи логарифмів ростуть аналогічно, тому вони поділяють одну і ту ж категорію log(n).

Переглядаючи приклади коду нижче, я рекомендую подивитися на O (1), потім O (n), потім O (n ^ 2). Після того, як ви добре з ними, тоді подивіться на інших. Я включив чисті приклади, а також варіанти, щоб продемонструвати, як тонкі зміни все ще можуть призвести до тієї ж категоризації.

Ви можете вважати O (1), O (n), O (logn) тощо як класи або категорії зростання. Для деяких категорій знадобиться більше часу, ніж для інших. Ці категорії допомагають дати спосіб упорядкувати роботу алгоритму. Деякі зростають швидше у міру зростання вхідних даних n. Наведена нижче таблиця демонструє чисельне зростання. У таблиці нижче вважайте log (n) як стелю log_2.

Прості кодові приклади різних категорій Big O:

O (1) - Приклади постійного часу:

• Алгоритм 1:

Алгоритм 1 друкує привіт один раз, і це не залежить від n, тому він завжди буде працювати в постійний час, так і є O(1).

print "hello";

• Алгоритм 2:

Алгоритм 2 друкує привіт 3 рази, однак це не залежить від розміру вводу. Навіть з ростом n цей алгоритм завжди буде надрукувати лише 3 рази. Це, як говорять 3, є постійною, тому цей алгоритм також є O(1).

print "hello";
print "hello";
print "hello";

O (log (n)) - логарифмічні приклади:

• Алгоритм 3 - Це діє як "log_2"

Алгоритм 3 демонструє алгоритм, який працює в log_2 (n). Зауважте, що операція циклу for для циклу кратна поточному значенню i на 2, тому iйде від 1 до 2 до 4 до 8 до 16 до 32 ...

for(int i = 1; i <= n; i = i * 2)
  print "hello";

• Алгоритм 4 - Це діє як "log_3"

Алгоритм 4 демонструє log_3. Повідомлення iйде від 1 до 3 до 9 до 27 ...

for(int i = 1; i <= n; i = i * 3)
  print "hello";

• Алгоритм 5 - Це діє як "log_1.02"

Алгоритм 5 важливий, оскільки він допомагає показати, що поки число більше 1 і результат неодноразово множиться на себе, ви дивитеся на логарифмічний алгоритм.

for(double i = 1; i < n; i = i * 1.02)
  print "hello";

O (n) - Приклади лінійного часу:

• Алгоритм 6

Цей алгоритм простий, який друкує привіт n разів.

for(int i = 0; i < n; i++)
  print "hello";

• Алгоритм 7

Цей алгоритм показує варіацію, де він буде надрукувати привіт п / 2 рази. n / 2 = 1/2 * n. Ми ігноруємо 1/2 константи і бачимо, що цей алгоритм є O (n).

for(int i = 0; i < n; i = i + 2)
  print "hello";

O (n * log (n)) - nlog (n) Приклади:

• Алгоритм 8

Подумайте про це як про поєднання O(log(n))та O(n). Вкладення циклів для петель допомагає нам отриматиO(n*log(n))

for(int i = 0; i < n; i++)
  for(int j = 1; j < n; j = j * 2)
    print "hello";

• Алгоритм 9

Алгоритм 9 схожий на алгоритм 8, але в кожній з циклів є варіанти, які все одно призводять до того, що кінцевий результат O(n*log(n))

for(int i = 0; i < n; i = i + 2)
  for(int j = 1; j < n; j = j * 3)
    print "hello";

O (n ^ 2) - n Приклади у квадраті:

• Алгоритм 10

O(n^2) виходить легко шляхом гніздування стандарт для петель.

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    print "hello";

• Алгоритм 11

Як алгоритм 10, але з деякими варіаціями.

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j = j + 2)
    print "hello";

O (n ^ 3) - n кубів Приклади:

• Алгоритм 12

Це як алгоритм 10, але з 3 петлями замість 2.

for(int i = 0; i < n; i++)
  for(int j = 0; j < n; j++)
    for(int k = 0; k < n; k++)
      print "hello";

• Алгоритм 13

Як алгоритм 12, але з деякими варіаціями, які все ще дають результат O(n^3).

for(int i = 0; i < n; i++)
  for(int j = 0; j < n + 5; j = j + 2)
    for(int k = 0; k < n; k = k + 3)
      print "hello";

Підсумок

Наведене вище дає кілька прямих прикладів та варіацій, які допоможуть продемонструвати, які тонкі зміни можуть бути внесені, що насправді не змінюють аналіз. Сподіваємось, це дає достатньо розуміння.

Якщо у вас була функція, яка займає:

1 millisecond to complete if you have 2 elements.
2 milliseconds to complete if you have 4 elements.
3 milliseconds to complete if you have 8 elements.
4 milliseconds to complete if you have 16 elements.
...
n milliseconds to complete if you have 2^n elements.

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

Логарифмічний час роботи ( O(log n)) по суті означає, що час виконання збільшується пропорційно логарифму вхідного розміру - як приклад, якщо 10 елементів займає максимум деяку кількість часу x, а 100 елементів займає максимум, скажімо 2x, і 10 000 елементів займає максимум 4x, то це виглядає як O(log n)складність у часі.

Логарифм

Гаразд, спробуємо і повністю зрозуміємо, що таке логарифм насправді.

Уявіть, у нас є мотузка, і ми прив’язали її до коня. Якщо мотузка безпосередньо прив’язана до коня, сила, яку коні потрібно буде відтягнути (скажімо, від людини), безпосередньо 1.

А тепер уявіть, що мотузка є петлею навколо стовпа. Коня, щоб відійти, тепер доведеться тягнути в багато разів сильніше. Кількість разів залежатиме від шорсткості мотузки та розміру жердини, але припустимо, що вона помножить силу на 10 (коли мотузка зробить повний поворот).

Тепер, якщо мотузку зациклити один раз, коня потрібно буде тягнути в 10 разів сильніше. Якщо людина вирішить зробити це справді важким для коня, він може знову зав'язати мотузку навколо жердини, збільшивши її силу ще в 10 разів. Третя петля знову збільшить міцність ще в 10 разів.

Ми можемо бачити, що для кожного циклу значення збільшується на 10. Кількість витків, необхідних для отримання будь-якого числа, називається логарифмом числа, тобто нам потрібно 3 повідомлення, щоб помножити вашу силу в 1000 разів, 6 постів, щоб помножити свою силу на 1 000 000.

3 - логарифм 1000, а 6 - логарифм 1 000 000 (основа 10).

Так що насправді означає O (log n)?

У нашому прикладі вище "наш темп зростання" - O (log n) . На кожну додаткову петлю сила нашої мотузки може в 10 разів більше:

Turns | Max Force
  0   |   1
  1   |   10
  2   |   100
  3   |   1000
  4   |   10000
  n   |   10^n

Зараз у наведеному вище прикладі було використано базу 10, але, на щастя, база журналу є незначною, коли ми говоримо про великі нотації.

Тепер давайте уявимо, що ви намагаєтесь відгадати число між 1-100.

Your Friend: Guess my number between 1-100! 
Your Guess: 50
Your Friend: Lower!
Your Guess: 25
Your Friend: Lower!
Your Guess: 13
Your Friend: Higher!
Your Guess: 19
Your Friend: Higher!
Your Friend: 22
Your Guess: Lower!
Your Guess: 20
Your Friend: Higher!
Your Guess: 21
Your Friend: YOU GOT IT!  

Тепер вам знадобилося 7 здогадок, щоб правильно це зробити. Але які стосунки тут? Яка найбільша кількість предметів, яку можна здогадатися з кожної додаткової здогадки?

Guesses | Items
  1     |   2
  2     |   4
  3     |   8
  4     |   16
  5     |   32
  6     |   64
  7     |   128
  10    |   1024

Використовуючи графік, ми можемо побачити, що якщо ми використовуємо двійковий пошук для відгадування числа між 1-100, це займе у нас не більше 7 спроб. Якби у нас було 128 чисел, ми могли б також здогадатися про число в 7 спроб, але 129 чисел знадобиться нам не більше 8 спроб (у відношенні до логарифмів тут нам знадобиться 7 здогадок для діапазону значень 128, 10 здогадок для діапазону значень 1024 7 - логарифм 128, 10 - логарифм 1024 (основа 2)).

Зауважте, що у мене є напівжирний шрифт. Нотація Big-O завжди стосується гіршого випадку. Якщо пощастить, ви можете вгадати число за одну спробу, і тому найкращий випадок - це O (1), але це вже інша історія.

Ми можемо бачити, що за кожною здогадкою наш набір даних скорочується. Добре правило, щоб визначити, чи має алгоритм логарифмічний час, - це перевірити, чи зменшується набір даних у певному порядку після кожної ітерації

А як щодо O (n log n)?

Зрештою, ви зіткнетеся з лінійно- алгоритмом лінійного часу O (n log (n)) . Зверху правило знову застосовується, але цього разу логарифмічна функція повинна запускатися n разів, наприклад, зменшуючи розмір списку n разів , що відбувається в алгоритмах, таких як об'єднання.

Ви можете легко визначити, чи алгоритмічний час n n n. Шукайте зовнішню петлю, яка повторюється через список (O (n)). Потім подивіться, чи є внутрішня петля. Якщо внутрішній цикл вирізає / зменшує набір даних для кожної ітерації, це цикл (O (log n)), і тому загальний алгоритм = O (n log n) .

Відмова: Приклад мотузкового логарифму був узятий із чудової книги Захоплення Математика У. Сойєра .

Ви можете думати про O (log N) інтуїтивно, кажучи, що час пропорційний кількості цифр у N.

Якщо операція виконує постійну роботу в часі на кожній цифрі або біті вводу, для всієї операції буде потрібно час, пропорційний кількості цифр або бітів на вході, а не величині вводу; таким чином, O (log N), а не O (N).

Якщо операція приймає серію постійних рішень у часі, кожна з яких наполовину (зменшується на коефіцієнт 3, 4, 5 ..) розмір вхідного матеріалу, який слід врахувати, то весь час займе час, пропорційний базі 2 журналу (база 3 , основа 4, основа 5 ...) розміром N вхідного сигналу, а не O (N).

І так далі.

Найкращий спосіб, який мені завжди доводилося подумки уявляти алгоритм, який працює в O (log n), полягає в наступному:

Якщо збільшити розмір проблеми на мультиплікативну суму (тобто помножити її розмір на 10), робота збільшується лише на суму добавки.

Застосувавши це до свого питання щодо двійкового дерева, щоб ви мали гарне застосування: якщо подвоїти кількість вузлів у двійковому дереві, висота збільшується лише на 1 (сума добавки). Якщо подвоїти його ще раз, він все одно збільшився лише на 1. (Очевидно, я припускаю, що він залишається врівноваженим і таким). Таким чином, замість того, щоб подвоювати свою роботу, коли розмір проблеми збільшується, ви робите лише трохи більше роботи. Ось чому алгоритми O (log n) є приголомшливими.

Спочатку рекомендую прочитати наступну книгу;

Алгоритми (4-е видання)

Ось деякі функції та їх очікувані складності. Числа позначають частоту виконання операторів .

Слідкуючи за діаграмою складності Big-O, також взятою з бігочехету

Нарешті, дуже проста вітрина показує, як вона обчислюється;

Анатомія частоти виконання операторів програми.

Аналіз часу виконання програми (приклад).

Що таке журнал _b (n)?

Це кількість разів, коли можна розрізати колоду довжиною n повторно на b рівних частинах, перш ніж досягти ділянки розміром 1.

Алгоритми ділення та підкорення зазвичай мають a logn компонент до часу виконання. Це відбувається від повторного скорочення вдвічі.

У разі двійкового пошуку, при кожній ітерації ви викидаєте половину вводу. Слід зазначити, що в нотації Big-O, журнал - це база журналів 2.

Редагувати: Як зазначалося, база журналу не має значення, але при виведенні продуктивності алгоритму Big-O фактор журналу вийде вдвічі, отже, чому я вважаю його базовим 2.

Але що саме таке O (log n)? Наприклад, що означає сказати, що висота> повного бінарного дерева дорівнює O (log n)?

Я б перефразував це як "висота повного двійкового дерева - це log n". Визначити висоту повного двійкового дерева було б O (log n), якби ви проходили крок за кроком.

Я не можу зрозуміти, як ідентифікувати функцію з логарифмічним часом.

Логарифм - це, по суті, обернена експоненція. Отже, якщо кожен "крок" вашої функції - це усунення фактора елементів з початкового набору елементів, це логарифмічний алгоритм часу.

На прикладі дерева можна легко побачити, що зменшення рівня вузлів скорочує експоненціальну кількість елементів під час продовження руху. Популярний приклад перегляду телефонної книги, упорядкованої за іменами, по суті еквівалентний обходу бінарного дерева пошуку (середня сторінка є кореневим елементом, і ви можете на кожному кроці виводити, чи їхати ліворуч або праворуч).

Ці 2 випадки займуть час O (log n)

case 1: f(int n) {
      int i;
      for (i = 1; i < n; i=i*2)
        printf("%d", i);
    }


 case 2  : f(int n) {
      int i;
      for (i = n; i>=1 ; i=i/2)
        printf("%d", i);
    }

O (log n) трохи вводить в оману, точніше, це O (log ₂₎ n), тобто (логарифм із базою 2).

Висота врівноваженого двійкового дерева становить O (log ₂ n), оскільки кожен вузол має два (відмітьте "два", як у журналі ₂ n) дочірні вузли. Отже, дерево з n вузлами має висоту log ₂ n.

Інший приклад - двійковий пошук, у якого час запуску O (log ₂ n), оскільки на кожному кроці ви ділите простір пошуку на 2.

O(log n) посилається на функцію (або алгоритм, або крок в алгоритмі), що працює в проміжок часу, пропорційний логарифму (як правило, база 2 в більшості випадків, але не завжди, і в будь-якому випадку це несуттєво за позначенням big-O *) розміру вводу.

Логарифмічна функція - обернена експоненціальна функція. По-іншому, якщо ваш внесок зростає експоненціально (а не лінійно, як ви зазвичай вважаєте), ваша функція зростає лінійно.

O(log n)Часи роботи дуже часто зустрічаються у будь-якому застосуванні «ділити і перемагай», оскільки ти (в ідеалі) щоразу розрізаєш роботу навпіл. Якщо в кожному з етапів поділу чи підкорення ви виконуєте постійну роботу в часі (або працюєте не в постійний час, але з часом зростаючи повільніше, ніж O(log n)), то вся ваша функція є O(log n). Досить часто кожен крок вимагає лінійного часу на вході; це становитиме загальну часову складністьO(n log n) .

Складність бінарного пошуку в часі - це приклад O(log n). Це тому, що в двійковому пошуку ви завжди ігноруєте половину свого введення на кожному наступному кроці, діливши масив навпіл і зосереджуючи увагу лише на одній половині з кожним кроком. Кожен крок є постійним часом, тому що в двійковому пошуку вам потрібно лише порівняти один елемент з вашим ключем, щоб зрозуміти, що робити далі, незалежно від того, наскільки великий масив ви розглядаєте в будь-який момент. Таким чином, ви зробите приблизно log (n) / log (2) кроки.

Прикладом є складність часу сортування злиття O(n log n). Це пов’язано з тим, що ви ділите масив навпіл з кожним кроком, в результаті чого ви отримаєте приблизно приблизно кроки log (n) / log (2). Однак на кожному кроці потрібно виконувати операції з’єднання над усіма елементами (будь то одна операція злиття на двох підсписках n / 2 елементів, або дві операції злиття на чотирьох підсписках n / 4 елементів, не має значення, оскільки це додає до необхідності зробіть це для n елементів на кожному кроці). Таким чином, загальна складність є O(n log n).

* Пам’ятайте, що позначення big-O, за визначенням , константи не мають значення. Крім зміни базового правила для логарифмів, єдина різниця між логарифмами різних основ є постійним фактором.

Це просто означає, що час, необхідний для виконання цього завдання, зростає з log (n) (приклад: 2s для n = 10, 4s для n = 100, ...). Прочитайте статті Вікіпедії про алгоритм бінарного пошуку та нотацію Big O для отримання більш точних даних.

Простіше кажучи: на кожному кроці алгоритму ви можете скоротити роботу навпіл. (Асимптотично рівнозначне третьому, четвертому, ...)

Якщо побудувати логарифмічну функцію на графічному калькуляторі чи щось подібне, ви побачите, що вона піднімається дійсно повільно - навіть повільніше, ніж лінійна функція.

Ось чому алгоритми з логарифмічною часовою складністю дуже затребувані: навіть для дійсно великих n (наприклад, n = 10 ^ 8, наприклад) вони виконують більш ніж прийнятно.

Але що саме таке O (log n)

Що це означає , що саме це «як nправило , в стороні infinity, то timeпрагне до a*log(n)якої aє постійним коефіцієнтом масштабування».

Або насправді це не зовсім означає; скоріше це означає щось на кшталт " timeрозділений на a*log(n)прагнення до 1".

"Схильний до" має звичайне математичне значення з "аналізу": наприклад, що "якщо ви вибираєте будь-яку довільно малу ненульову константу k, то я можу знайти відповідне значення Xтаке, яке ((time/(a*log(n))) - 1)менше, ніж kдля всіх значень nбільше X".

Простіше кажучи, це означає, що рівняння часу може містити деякі інші компоненти: наприклад, воно може мати деякий постійний час запуску; але ці інші компоненти бліді до незначущості для великих значень n, а a * log (n) є домінуючим терміном для великих n.

Зауважте, якби рівняння були, наприклад ...

час (n) = a + b log (n) + c n + d n n

... тоді це буде O (n квадрат), тому що, незалежно від значень констант a, b, c і ненульових d, d*n*nтермін завжди буде домінувати над іншими при будь-якому досить великому значенні n.

Ось що означає позначення біт O: воно означає "який порядок домінуючого терміна для будь-якого досить великого n".

Я можу додати щось цікаве, що я давно прочитав у книзі Кормена тощо. Тепер уявіть собі проблему, де нам потрібно знайти рішення в просторі проблеми. Цей проблемний простір повинен бути кінцевим.

Тепер, якщо ви можете довести, що при кожній ітерації вашого алгоритму ви відрізаєте частину цього простору, тобто не менше деякої межі, це означає, що ваш алгоритм працює в O (logN) час.

Я мушу зазначити, що ми говоримо тут про відносну межу частки, а не про абсолютну. Двійковий пошук - класичний приклад. На кожному кроці ми викидаємо 1/2 проблемного простору. Але двійковий пошук - не єдиний подібний приклад. Припустимо, ви якось довели, що на кожному кроці ви викидаєте щонайменше 1/128 проблемного простору. Це означає, що ваша програма все ще працює в O (logN) час, хоча значно повільніше, ніж двійковий пошук. Це дуже хороший натяк на аналіз рекурсивних алгоритмів. Часто можна довести, що на кожному етапі рекурсія не буде використовувати кілька варіантів, і це призводить до відсічення деякої фракції в проблемному просторі.

Я можу навести приклад для циклу for і, можливо, колись зрозумів це поняття, можливо, це буде простіше зрозуміти в різних контекстах.

Це означає, що в циклі крок росте експоненціально. Напр

for (i=1; i<=n; i=i*2) {;}

Складність O-позначення цієї програми становить O (log (n)). Спробуємо провести цикл через нього вручну (n знаходиться десь між 512 та 1023 (без 1024):

step: 1   2   3   4   5    6    7    8     9     10
   i: 1   2   4   8   16   32   64   128   256   512

Хоча n десь між 512 і 1023, відбувається лише 10 ітерацій. Це відбувається тому, що крок у циклі зростає експоненціально і, отже, потрібно лише 10 ітерацій, щоб досягти припинення.

Логарифм x (до основи a) - це зворотна функція a ^ x.

Це як би сказати, що логарифм є зворотною експоненціальною.

Тепер спробуйте побачити це таким чином, якщо експоненція росте дуже швидко, то логарифм росте (навпаки) дуже повільно.

Різниця між O (n) і O (log (n)) величезна, подібна до різниці O (n) і O (a ^ n) (істота, яка є постійною).

Насправді, якщо у вас є список з n елементів та створіть бінарне дерево із цього списку (як, наприклад, в алгоритмі ділення та підкорення), ви продовжуватимете ділення на 2, поки не досягнете списків розміром 1 (листя).

На першому кроці ви ділите на 2. Потім у вас є 2 списки (2 ^ 1), ви ділите кожен на 2, тому у вас є 4 списки (2 ^ 2), ви ділите знову, у вас є 8 списків (2 ^ 3) ) тощо, поки розмір вашого списку не дорівнює 1

Це дає вам рівняння:

n/(2^steps)=1 <=> n=2^steps <=> lg(n)=steps

(ви берете lg кожної сторони, lg - це база журналу 2)

Кожен раз, коли ми пишемо алгоритм чи код, ми намагаємось проаналізувати його асимптотичну складність. Він відрізняється своєю часовою складністю .

Асимптотична складність - це поведінка часу виконання алгоритму, тоді як складність часу - фактичний час виконання. Але деякі люди використовують ці терміни взаємозамінно.

Оскільки складність часу залежить від різних параметрів, а саме.
1. Фізична система
2. Мова програмування
3. Стиль кодування
4. І багато іншого ......

Фактичний час виконання не є хорошим показником для аналізу.

Замість цього ми беремо розмір введення як параметр, оскільки який би код не був, вхід є однаковим. Отже час виконання - це функція від розміру вводу.

Далі наводиться приклад лінійного алгоритму часу

Лінійний пошук
З огляду на п ять вхідних елементів, для пошуку елемента в масиві потрібно не більше, ніж 'n' порівнянь . Іншими словами, незалежно від того, якою мовою програмування ви користуєтесь, який стиль кодування ви надаєте перевагу, в якій системі ви його виконуєте. У гіршому випадку потрібно лише порівняння n. Час виконання лінійно пропорційний розміру вводу.

І це не просто пошук, якою б не була робота (приріст, порівняння чи будь-яка операція), це функція розміру вводу.

Отже, коли ви говорите, що будь-який алгоритм є O (log n), це означає, що час виконання - це журнал, розмір вхідний n.

Зі збільшенням розміру введення збільшується виконана робота (тут час виконання) збільшується. (Отже, пропорційність)

      n      Work
      2     1 units of work
      4     2 units of work
      8     3 units of work

Побачте, як збільшується розмір вводу, збільшується виконана робота і вона не залежить від будь-якої машини. І якщо ви спробуєте дізнатись значення одиниць роботи, це насправді залежить від тих, хто вище зазначених параметрів. Він зміниться відповідно до систем та всіх.

log x to base b = y є зворотним b^y = x

Якщо у вас є дерево A-глибини глибини d та розміру n, то:

• обхід всього дерева ~ O (M ^ d) = O (n)

• Ходьба єдиним шляхом у дереві ~ O (d) = O (log n до основи M)

В інформаційних технологіях це означає, що:

  f(n)=O(g(n)) If there is suitable constant C and N0 independent on N, 
  such that
  for all N>N0  "C*g(n) > f(n) > 0" is true.

Здається, що це позначення здебільшого взяли з математики.

У цій статті є цитата: Де Кнут, "ВЕЛИКИЙ ОМИКРОН І ВЕЛИКА ОМЕГА І ВЕЛИКА ТЕТА", 1976 :

На підставі обговорюваних тут питань я пропоную членам SIGACT та редакторам журналів інформатики та математики прийняти позначення, як визначено вище, якщо тільки краща альтернатива не може бути знайдена досить скоро .

Сьогодні 2016 рік, але ми використовуємо його і сьогодні.

У математичному аналізі це означає, що:

  lim (f(n)/g(n))=Constant; where n goes to +infinity

Але навіть у математичному аналізі іноді цей символ вживався у значенні "C * g (n)> f (n)> 0".

Як я знаю з університету, символ був індукований німецьким математиком Ландау (1877-1938)

Повний бінарний приклад - O (ln n), оскільки пошук виглядає так:

1 2 3 4 5 6 7 8 9 10 11 12

Якщо шукати 4, ви отримуєте 3 хіти: 6, 3 потім 4. І log2 12 = 3, що є хорошим підсумком кількості звернень, де потрібно.

Якщо ви шукаєте відповідь на основі інтуїції, я хотів би скласти для вас дві інтерпретації.

1. Уявіть дуже високий пагорб із дуже широкою основою. Довершитись до вершини пагорба можна двома шляхами: один - це спеціально виділена доріжка, що проходить спірально навколо пагорба, що досягає вгорі, інша: невелика тераса, наче різьба, вирізана для отримання сходів. Тепер, якщо перший шлях досягає в лінійному часі O (n), другий - O (log n).

2. Уявіть алгоритм, який приймає ціле число, nяк вхідне і завершує в часі, пропорційному nтому, що це O (n) або theta (n), але якщо він працює в часі, пропорційному number of digits or the number of bits in the binary representation on numberтоді алгоритм працює в O (log n) або theta (log n) час.

Алгоритми в парадигмі ділення та перемоги мають складність O (logn). Один приклад тут, обчисліть власну функцію живлення,

int power(int x, unsigned int y)
{
    int temp;
    if( y == 0)
        return 1;
    temp = power(x, y/2);
    if (y%2 == 0)
        return temp*temp;
    else
        return x*temp*temp;
}

від http://www.geeksforgeeks.org/write-ac-program-to-calculate-powxn/