Как точно определить O (nlogn)? - PullRequest
2 голосов
/ 14 апреля 2019

Я понял O (logn) в том смысле, что он быстро увеличивается, но при больших входах скорость увеличения замедляется. Я не могу полностью понять

  1. O (nlogn)

  2. разница между алгоритмом со сложностью nlogn и сложностью n + logn.

Я мог бы использовать модификацию примера телефонной книги и / или некоторый базовый код Python, чтобы понять два запроса

Ответы [ 4 ]

5 голосов
/ 14 апреля 2019

Как вы относитесь к O(n ^ 2)?Лично мне нравится думать об этом как о O(n) работе O(n) раз.

Придуманный алгоритм O(n ^ 2) будет повторять все пары чисел в 0, 1, ..., n - 1

def print_pairs(n):
    for i in range(n):
        for j in range(i + 1, n):
            print('({},{})'.format(i, j))

Используя логику, аналогичную описанной выше, вы могли бы O(log n) работать O(n) раз и иметь временную сложность O(n log n).

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

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

def find_indices(arr):
    indices = []
    for num in arr:
        index = binary_search(arr, 0, len(arr), num)
        indices.append(index)
    return indices

def binary_search(arr, l, r, x): 

    # Check base case 
    if r >= l: 

        mid = l + (r - l)/2

        # If element is present at the middle itself 
        if arr[mid] == x: 
            return mid 

        # If element is smaller than mid, then it  
        # can only be present in left subarray 
        elif arr[mid] > x: 
            return binary_search(arr, l, mid-1, x) 

        # Else the element can only be present  
        # in right subarray 
        else: 
            return binary_search(arr, mid + 1, r, x) 

    else: 
        # Element is not present in the array 
        return -1

Что касается вашего второго вопроса, то, конечно, log n << n при n стремится к бесконечности, поэтому

O(n + log n) = O(n)

Теоретически, log n затмевается на n, так как мы получаем произвольно большие значения, поэтому мы не включаем его в наш анализ Big O.

Сопоставляется с практикой, гдеВы можете рассмотреть эту дополнительную log n работу, если ваш алгоритм испытывает проблемы с производительностью и / или масштабированием.

1 голос
/ 14 апреля 2019

log n намного медленнее, чем n.Когда компьютерные ученые говорят о big-O, они заинтересованы в расширении функции для чрезвычайно больших входных значений.То, что функция делает вблизи некоторого небольшого числа или точки перегиба, несущественно.

Многие распространенные алгоритмы имеют временную сложность n log n.Например, сортировка слиянием требует, чтобы n шагов было сделано log_2(n) раз, поскольку входные данные делятся пополам.После изучения алгоритма тот факт, что его сложность составляет n log n, может прийти к вам интуитивно, но вы можете прийти к тому же выводу, изучив рекуррентное соотношение, описывающее (рекурсивный) алгоритм - в данном случае T(n) = 2 * T(n / 2) + n.В более общем смысле, но, возможно, наименее интуитивно, для получения этого выражения n log n можно применить основную теорему .Короче говоря, не пугайтесь, если не сразу понятно, почему определенные алгоритмы имеют определенное время выполнения - есть много способов прибегнуть к анализу.

Относительно «сложности n + log n»это не то, как нотация big-O имеет тенденцию привыкать.У вас может быть алгоритм, который работает n + log n, но вместо того, чтобы называть его O(n + log n), мы бы назвали его O(n), потому что n растет намного быстрее, чем log n, что термин log n ничтожно мал.Смысл big-O состоит в том, чтобы указывать только скорость роста самого быстро растущего термина.

По сравнению с n log n, log n быстрее.Если log n - это временная сложность вставки элемента в самообалансированное дерево поиска, n log n будет сложностью вставки n элементов в такую ​​структуру.

0 голосов
/ 14 апреля 2019

Технически алгоритмы со сложностью O (n + log n) и сложностью O (n) одинаковы, так как член log n становится пренебрежимо малым при росте n.

O (n) растет линейно.Наклон постоянен.

O (n log n) растет суперлинейно.Наклон увеличивается (медленно).

0 голосов
/ 14 апреля 2019

Существует Алгоритмы Гроккинга Потрясающая книга, которая объясняет детальное обнаружение сложности алгоритмов (среди прочего) исчерпывающим и очень простым языком.

...