1. Он должен быть корректен. Какой от него толк, если он не дает правильные ответы.
2. Хороший алгоритм должен быть понятен. Даже самый лучший алгоритм не даст пользы, если его слишком сложно реализовать на компьютере.
3. Хороший алгоритм должен быть эффективным. Даже если алгоритм дает корректный результат, он не сильно поможет, если для этого потребуется тысячи лет или миллиард терабайтов памяти.

Теория сложности изучает последнее свойство алгоритмов (Хороший алгоритм должен быть эффективным).

Есть несколько типов сложности, первый и самый очевидный тип — это временная сложность. Многие алгоритмы ограничены своей скоростью, поэтому важно знать, сколько времени требуется алгоритму, чтобы решить задачу.

Второй тип — это пространственное сложность. Некоторые алгоритмы использует много памяти или дисковое пространство. Например, хеш таблицы используют больше пространство чем другие структуры данных и это позволяет им находит элементы очень быстро. Другие алгоритмы могут использовать и другие ресурсы, например, алгоритму может требоваться сетевое взаимодействие, в этом случае программа может быть ограничена ширеной канала. Еще алгоритмы могут полагаться на графические ресурсы и также на другие типы оборудование, например, принтеры, 3D принтеры, CPU, сенсоры и другие.

Нужно понимать условия работы алгоритма. Самая простая ситуация — это когда алгоритм дает одинаковую производительность в каждом случае, не важно какие входные данные, производительность не меняется. Но тем не менее производительность некоторых алгоритмов зависит от входных данных. Некоторые алгоритмы хорошо справляются с одним набором данных, но ужасно с другим. Например, такое поведение есть у алгоритма быстрой сортировки. Это очень быстрый алгоритм для сортировки рандомных / случайных чисел, но если числа уже отсортированы, то он становится ужасно медленным.



Для таких алгоритмов, как быстрая сортировка, нужно учитывать поведение в лучшем случае, среднем и худшем случае. Чтобы быть в безопасности, люди часто концентрируются на наихудшем случае. Для многих алгоритмов также полезно рассмотреть ожидаемое случае. В случаи с быстрой сортировкой большинство приложение сортируют более или менее рандомные данные, в этом ожидаемом случае быстрая сортировка работает хорошо.

Теперь вы знаете о типах сложности и условиях, которые могут дать разное поведение. Возможно, вы задались вопросом — Зачем об этом беспокоиться? действительно ли нужно анализировать алгоритм, чтобы доказать его поведение? Нельзя ли просто выполнить его и посмотреть, подходит или нет? Ответ — конечно можно! Попробуйте алгоритм и посмотрите, что произойдет. Но если алгоритм недостаточно быстро работает или у вас недостаточно памяти, то вы потратите много времени. А можно было сразу предсказать, что алгоритм работать не будет. Это одна из причин изучать сложность алгоритмов, уметь предсказывать их поведение. Другая причина — это сравнение производительности с другими алгоритмами. Если вы знаете, что вы будете сортировать уже по большей части отсортированные данные, то используйте сортировку пузырьком, она плоха для рандомных данных, но быстро работает, если данные в основном сортированы.

Если вы понимаете разницу между быстрой сортировкой и сортировкой пузырьком, то сможете выбрать правильную для свои задачи. И конце концов, изучение сложности поможет вам доказывать характеристики алгоритма. Например, криптографические алгоритмы делают очень сложную расшифровку сообщение, если вы не знаете ключ, с которым оно было зашифровано. Это один из тех случаев, когда нужно чтобы алгоритм было медленным. Атакующий может взломать код и увидеть сообщение, но это не важно, если для расшифровки сообщений может потребоваться много лет.

The post Теория сложности алгоритмов appeared first on HackerX.

Так же нотация «большое О» рассматривает асимптотическое поведение алгоритма. Асимптотическое поведение — это производительность алгоритма при росте размера задачи. Часто размер задачи обозначается как N. Чтобы описать асимптотическое поведение, нужно ответить на вопрос — что случится с производительностью алгоритма, если N сильно вырастет?

Предположите, что вам нужно отсортировать список чисел у вас есть несколько алгоритмов, которые можно использовать. Если список содержит два числа, то есть N=2, то в этом случае не важно какой алгоритм вы используете. Любой алгоритм это сделает за несколько микросекунд.Теперь представим, что в списке есть 10 чисел (N=10), это тоже небольшой список и любой алгоритм будет достаточно быстро сортировать. А предположим, что в списке 100 чисел или 1000 или миллион, тут все становится интереснее.

Отсортировать миллион чисел на компьютере не сложно, но теперь выбор алгоритма может дать разницу. Некоторые алгоритмы сортировки намного быстрее других, поэтому одни могут отсортировать список за несколько секунд а другим потребуется несколько часов. Это именно то, что нужно понять под асимптотическим поведением.

Нотация «большое О» рассматривает производительность алгоритма при росте задачи, потому что только тогда мы сильно беспокоимся. Так как выяснить нотацию «большое О» для алгоритма? Нужно следовать 5 правилам.

1. Если алгоритм выполняет f(N) шагов для какой то математической функции f, то у алгоритма производительность порядка f от N. Пишется так: O(f(N)).

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

Пример на языке JavaScript:

var max = value[0];
 
for ( var i = 0; i < N; i++ ) {
    if ( value[i] > max ) {
        max = value[i];
    }
}

Переменная max содержит первое значение из массива. Затем выполняется цикл по массиву значений. Если находится значение больше чем max, то max обновляется этим значением. Для массива содержащий N элементов, цикл выполняет N шагов. У этого алгоритма поведение O(N). Это просто линейная функция O(N) = N.

2. Если алгоритм выполняет f(N) шагов а затем g(N) шагов то у него поведение O(f(N) + g(N)).

Давайте рассмотрим этот алгоритм для нахождение максимального и минимального значение в массиве.

var max = value[0];
 
for ( var i = 0; i < N; i++ ) {
    if ( value[i] > max ) {
        max = value[i];
    }
}


var min = value[0];

for ( var i = 0; i < N; i++ ) {
    if ( value[i] < min ) {
        min = value[i];
    }
}

Начинаем как и раньше, находя максимальное значение. А затем выполняем практически те же шаги, чтобы найти минимальное. Код сначало выполняет N шагов а потом еще раз выполняет N шагов. Его поведение O(N + N) или O(2N).

Если алгоритм выполняет какие то шаги а потом еще какие то, то эти поведение суммируется.

3. Если функция f больше функций g: f(N) > g(N), то можно для больших задач упростит:  O(f(N) + g(N)) = O(f(N)).

По сути можно округлять, поскольку f больше чем g и в итоге время выполнение функции f будет доминировать, поэтому g можно игнорировать.

Предположим, что алгоритм выполняется N² шагов а затем еще N шагов. Функция N² больше чем N для больших N-ов, так что производительность этого алгоритма N². Чтобы понять почему так, давайте рассмотрим кое-какие цифры.

А теперь давайте посчитаем сколько шагов нужно программе когда N = 10, N² = 100 и N² + N = 110. На этом этапе дополнительное N — это только 10%-ов от общего количество шагов.

Мы видим из таблицы, что при росте задачи дополнительно выполняемые шаги N добавляют все меньше и меньше процентов к общему количеству шагов.

Если этот алгоритм используется в программе, то времени потраченные на дополнительные шаги N будет все меньше и меньше. Например, если N = 100,000 и программе требуется час для выполнение, то дополнительные шаги добавляют лишь третью часть секунды. Об этом просто не стоит беспокоиться.

Обратите внимание, также это правило означает, что можно игнорировать константы, добавляемые к функции: O(C + f(N)) = O(f(N)). Константа C — это тоже функция с константным значением. Поскольку константа меньше чем любая функция, которая увеличивается при увеличение N, можно игнорировать константу.

4. Если алгоритм выполняет g(N) шагов для каждого из f(N) шагов, то это поведение O(f(N) × g(N)). × Знак умножения.

Вот этот алгоритм определяет есть ли в массиве два одинаковых значение.

for ( var i = 1; i < N; i++ ) {
    for ( var j = 1; j < N; i++ ) {
        if ( i != j && value[i] == value[j] ) {
              return true;
        }
    }
}

Первый цикл проходится по N элементов в массиве, для каждого из элементов второй цикл (внутренние) тоже проходится по N элементов в массиве. Это означает, что поведение алгоритма O(N × N) или O(N²).

5. Можно игнорировать умножение на константи: O(C × f(N)) = O(f(N)) и O(f(C × N)) = O(f(N)).

Представим, что один алгоритм выполняет порядка N² шагов а другой 2 × N² шагов. Даже когда N большое, второму алгоритму понадобится два раза больше времени чем первому. В этом случае нотация «большое О» не позволяет сравнить эти два алгоритма, но их можно сравнить с алгоритмами у которых другая нотация «большое О». Для больших N оба будут медленнее чем алгоритмы O(N) и оба будут быстрее чем алгоритмы O(N²).

Это были правила нотации «большого О». В следующих статьях мы продолжим разговор об алгоритмах.

The post Нотация «большое О». Изучение производительности алгоритмов appeared first on HackerX.