Як знайти складність алгоритму в часі

Питання

Як знайти складність алгоритму в часі?

Що я зробив перед тим, як поставити запитання на SO?

Я пройшов через це , це та багато інших посилань

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

Що я знаю?

Скажіть код простий, як наведений нижче:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

Скажіть цикл, як описано нижче:

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

int i = 0; Це буде виконано лише один раз . Час фактично обчислюється, i=0а не декларацією.

i <N; Це буде виконано N + 1 раз

i ++; Це буде виконано N разів

Отже, кількість операцій, необхідних для цього циклу, становить

{1+ (N + 1) + N} = 2N + 2

Примітка. Це все ж може бути неправильним, оскільки я не впевнений у своєму розумінні щодо обчислення складності часу

Що я хочу знати?

Гаразд, такі невеликі основні розрахунки, я думаю, знаю, але в більшості випадків я сприймав складність часу як

O (N), O (n2), O (log n), O (n!) .... та багато інших ,

Хтось може допомогти мені зрозуміти, як можна обчислити складність часу алгоритму? Я впевнений, що є багато новачків, як я, які хочуть це знати.

Як знайти складність алгоритму в часі

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

Наприклад, давайте подивимось, як ми спрощуємо 2N + 2інструкції машини, щоб описати це як просто O(N).

Чому ми видаляємо два 2s?

Нас цікавить продуктивність алгоритму, оскільки N стає великим.

Розглянемо два доданки 2N та 2.

Який відносний вплив цих двох доданків, коли N стає великим? Припустимо, N - це мільйон.

Тоді перший термін - 2 мільйони, а другий термін - лише 2.

З цієї причини ми відкидаємо всі великі Н., крім найбільших, терміни.

Отже, зараз ми перейшли з 2N + 2до 2N.

Традиційно нас цікавлять лише ефективність, яка не залежить від постійних факторів .

Це означає, що нас насправді не хвилює, чи є якийсь постійний кратний різниця в продуктивності, коли N великий. Одиниця 2N все одно недостатньо чітко визначена. Таким чином, ми можемо множити або ділити на постійний множник, щоб дійти до найпростішого виразу.

Так 2Nстає справедливим N.

Це відмінна стаття: http://www.daniweb.com/software-development/computer-science/threads/13488/time-complexity-of-algorithm

Нижче відповідь скопіюється зверху (у випадку, якщо відмінна посилання перешкодить)

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

statement;

Постійна. Час запуску заяви не зміниться стосовно Н.

for ( i = 0; i < N; i++ )
     statement;

Є лінійним. Час роботи циклу прямо пропорційне N. Коли N подвоюється, то і час виконання.

for ( i = 0; i < N; i++ ) {
  for ( j = 0; j < N; j++ )
    statement;
}

Квадратний. Час виконання двох циклів пропорційно квадрату N. Коли N подвоюється, час роботи збільшується на N * N.

while ( low <= high ) {
  mid = ( low + high ) / 2;
  if ( target < list[mid] )
    high = mid - 1;
  else if ( target > list[mid] )
    low = mid + 1;
  else break;
}

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

void quicksort ( int list[], int left, int right )
{
  int pivot = partition ( list, left, right );
  quicksort ( list, left, pivot - 1 );
  quicksort ( list, pivot + 1, right );
}

Чи N * log (N). Час виконання складається з N циклів (ітеративних або рекурсивних), які є логарифмічними, таким чином алгоритм є комбінацією лінійної та логарифмічної.

Загалом, робити щось із кожним предметом в одному вимірі лінійно, робити щось із кожним предметом у двох вимірах є квадратичним, а ділення робочої зони навпіл логарифмічно. Існують і інші заходи Big O, такі як кубічний, експоненціальний та квадратний корінь, але вони майже не такі поширені. Велика нотація O описується як O ( <type> )де <type>міра. Алгоритм quicksort буде описаний як O ( N * log ( N ) ).

Зауважте, що жодне з цього не враховувало кращих, середніх та найгірших заходів. У кожного буде своя велика нотація O. Також зауважте, що це ДУЖЕ спрощене пояснення. Великий О - це найпоширеніший, але він також більш складний, що я показав. Існують також інші позначення, такі як велика омега, маленька о та велика тета. Ви, мабуть, не зустрінете їх поза курсом аналізу алгоритмів. ;)

Взято звідси - Вступ до складності часу алгоритму

1. Введення

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

2. Велика нотація O

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

Наприклад, якщо час, необхідний алгоритмом на всіх входах розміром n, становить не більше 5n ³ + 3n, асимптотична складність часу дорівнює O (n ³ ). Детальніше про це пізніше.

Ще кілька прикладів:

• 1 = O (n)
• n = O (n ² )
• log (n) = O (n)
• 2 n + 1 = O (n)

3. O (1) Постійний час:

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

Приклади:

• масив: доступ до будь-якого елемента
• стек фіксованого розміру: методи push та pop
• черга фіксованого розміру: методи зачіпки та відстрочення

4. O (n) лінійний час

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

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

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

Більше прикладів:

• Масив: лінійний пошук, проїзд, пошук мінімуму тощо
• ArrayList: містить метод
• Черга: містить метод

5. O (log n) Логарифмічний час:

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

Приклад: Двійковий пошук

Згадайте гру «двадцять питань» - завдання вгадати значення прихованого числа за проміжок часу. Кожен раз, коли ви здогадуєтесь, вам повідомляють, занадто висока чи занадто низька ваша здогадка. Гра з двадцятьма питаннями передбачає стратегію, яка використовує число ваших здогадок, щоб вдвічі зменшити розмір інтервалу. Це приклад загального методу вирішення проблем, відомого як двійковий пошук

6. O (n ² ) Квадратичний час

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

Приклади:

• Сортування бульбашок
• Сортування вибору
• Сортування вставки

7. Деякі корисні посилання

• Помилки Big-O
• Визначення складності алгоритму
• Big O шпаргалка

Хоча є кілька хороших відповідей на це питання. Я хотів би дати тут ще одну відповідь з кількома прикладами loop.

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

  // Here c is a positive integer constant   
  for (int i = 1; i <= n; i += c) {  
      // some O(1) expressions
  }
  
  for (int i = n; i > 0; i -= c) {
      // some O(1) expressions
  }
  

• O (n ^ c) : Час складності вкладених циклів дорівнює кількості виконаних найпотужніших операторів. Наприклад, наступні цикли вибірки мають часову складність O (n ^ 2)

  for (int i = 1; i <=n; i += c) {
     for (int j = 1; j <=n; j += c) {
        // some O(1) expressions
     }
  }
  
  for (int i = n; i > 0; i += c) {
     for (int j = i+1; j <=n; j += c) {
        // some O(1) expressions
  }
  

  Наприклад, сортування селекції та сортування вставки мають часову складність O (n ^ 2) .

• Час O (Logn) Складність циклу вважається O (Logn), якщо змінні циклу ділять / множать на постійну величину.

  for (int i = 1; i <=n; i *= c) {
     // some O(1) expressions
  }
  for (int i = n; i > 0; i /= c) {
     // some O(1) expressions
  }
  

  Наприклад, двійковий пошук має складну часову складність O (Logn) .

• O (LogLogn) Часова складність циклу вважається O (LogLogn), якщо змінні циклу зменшуються / збільшуються експоненціально на постійну величину.

  // Here c is a constant greater than 1   
  for (int i = 2; i <=n; i = pow(i, c)) { 
     // some O(1) expressions
  }
  //Here fun is sqrt or cuberoot or any other constant root
  for (int i = n; i > 0; i = fun(i)) { 
     // some O(1) expressions
  }
  

Один приклад аналізу складності часу

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

Аналіз :

For i = 1, the inner loop is executed n times. For i = 2, the inner loop is executed approximately n/2 times. For i = 3, the inner loop is executed approximately n/3 times. For i = 4, the inner loop is executed approximately n/4 times. ……………………………………………………. For i = n, the inner loop is executed approximately n/n times.

Таким чином, загальна часова складність вищевказаного алгоритму є (n + n/2 + n/3 + … + n/n), що стаєn * (1/1 + 1/2 + 1/3 + … + 1/n)

Важливе, що стосується серій (1/1 + 1/2 + 1/3 + … + 1/n), дорівнює O (Logn) . Отже, складність у часі наведеного вище коду дорівнює O (nLogn) .

Посилання: 1 2 3

Складність часу з прикладами

1 - Основні операції (арифметика, порівняння, доступ до елементів масиву, призначення): час роботи завжди постійний O (1)

Приклад:

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

2 - Якщо тоді інше твердження: лише взяття максимального часу роботи з двох або більше можливих операторів.

Приклад:

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

Отже, складність вищевказаного псевдокоду становить T (n) = 2 + 1 + max (1, 1 + 2) = 6. Отже, його велике о все ще є постійним T (n) = O (1).

3 - Цикли (для, поки повторіть): час виконання цього оператора - це число циклічного циклу, помножене на кількість операцій всередині цього циклу.

Приклад:

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

Отже, її складність становить T (n) = 1 + 4n + 1 = 4n + 2. Отже, T (n) = O (n).

4 - Вкладений цикл (циклічне внутрішнє циклічне циклічне): Оскільки є щонайменше одна петля всередині основної петлі, час виконання цього оператора використовує O (n ^ 2) або O (n ^ 3).

Приклад:

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

Загальний час роботи

При аналізі алгоритму існують деякі поширені час роботи:

1. O (1) - Постійний час Постійний час означає, що час роботи є постійним, на нього не впливає розмір вводу .

2. O (n) - лінійний час Коли алгоритм приймає n вхідного розміру, він також буде виконувати n операцій.

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

4. O (n log n) - лінійний часовий час Цей час роботи часто зустрічається в "алгоритмах ділення та підкорення", які розділяють проблему на підзадачі рекурсивно, а потім об'єднують їх у n час. Приклад: Алгоритм сортування злиття.

5. O (n ² ) - квадратичний алгоритм сортування бульбашок у часі!

6. O (n ³ ) - кубічний час Він має той же принцип з O (n ² ).

7. O (2 ⁿ ) - Експоненційний час Це дуже повільно, оскільки вхід збільшується, якщо n = 1000.000, T (n) було б 21000.000. Алгоритм Brute Force має цей час роботи.

8. О (п!) - Факторський час НАЙСЛОВНІШИЙ !!! Приклад: Проблема продавця подорожей (TSP)

Взято з цієї статті . Дуже добре пояснено, слід прочитати.

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

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

Давайте розглянемо, які є можливості для складності часу алгоритму, ви можете побачити порядок зростання, про який я згадував вище:

• Постійне час має порядок зростання1, наприклад:a = b + c.

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

• NНаприклад, лінійний порядок зростання

  int p = 0;
  for (int i = 1; i < N; i++)
    p = p + 2;
  

• Лінійноарифмічний порядок зростанняn*logN, як правило, відбувається в алгоритмах ділення та підкорення.

• Кубічний , порядок зростанняN^3, класичний приклад - потрійний цикл, де ви перевіряєте всі трійки:

  int x = 0;
  for (int i = 0; i < N; i++)
     for (int j = 0; j < N; j++)
        for (int k = 0; k < N; k++)
            x = x + 2
  

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

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

Як і більшість речей у житті, коктейль може допомогти нам зрозуміти.

O (N)

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

Чому O(N)і ні cN?

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

O (N ^ 2)

Ведуча коктейлю хоче, щоб ви пограли в дурну гру, де всі зустрічаються з усіма іншими. Тому ви повинні зустріти N-1інших людей, і тому, що наступна людина вже познайомилася з вами, вони повинні зустріти N-2людей тощо. Сума цієї серії становить x^2/2+x/2. Зі збільшенням кількості відвідувачів x^2термін швидко збільшується , тому ми просто кидаємо все інше.

O (N ^ 3)

Ви повинні зустрітися з усіма іншими, і під час кожної зустрічі ви повинні говорити про всіх інших у кімнаті.

O (1)

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

O (журнал N)

Ведучий розклав усіх за столом в алфавітному порядку. Де Дан? Ви вважаєте, що він повинен бути десь між Адамом та Менді (звичайно, не між Менді та Заком!). Враховуючи це, він між Джорджем і Менді? Ні. Він повинен бути між Адамом та Фредом та між Сінді та Фредом. І так далі ... ми можемо ефективно знайти Дана, переглянувши половину, а потім половину цього набору. Зрештою, ми дивимось на O (log_2 N) осіб.

O (N журналу N)

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

Найкращий / гірший випадок

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

Припускаючи, що хост недоступний, можна сказати, що алгоритм пошуку Inigo має нижню O(log N)і верхню межу O(N), залежно від стану учасника, коли ви приїдете.

Простір та спілкування

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

Кнут написав приємний документ про колишню назву "Складність пісень" .

Теорема 2: Існують довільно довгі пісні складності O (1).

ДОКАЗАННЯ: (завдяки Кейсі та Sunshine Band). Розглянемо пісні Sk, визначені (15), але з

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

для всіх k.

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

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

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

тут загальна кількість виконань для внутрішнього циклу - n + 1, а загальна кількість виконань для зовнішнього циклу - n (n + 1) / 2, тому загальна кількість виконань для цілого алгоритму становить n + 1 + n (n + 1/2 ) = (n ^ 2 + 3n) / 2. тут n ^ 2 є домінуючим терміном, тому складність у часі для цього алгоритму становить O (n ^ 2)