Что лучше: O (N log n) или O (N^2)

хорошо, поэтому у меня есть этот проект, который я должен сделать, но я его просто не понимаю. Дело в том, что у меня есть 2 алгоритма. O (n^2) и O (n*log2n).

в любом случае, я узнаю в информации о проекте, что если n, потом O (n^2) более эффективно, но если n > =100, потом O (n*log2n) более эффективно. Я должен продемонстрировать на примере, используя числа и слова или рисование фотографии. Но дело в том, что я этого не понимаю и не знаю, как это продемонстрировать.

кто-нибудь может помочь мне понять, как это работает?

Ура заранее!

EDIT: спасибо всем за ответы.

22
algorithm big-o

6 ответов

просто спросить русский если у вас есть сомнения.

в этом случае, он говорит

     n log(n)
lim --------- = 0
       n^2

или вы также можете рассчитать ограничивать себя:

     n log(n)        log(n)   (Hôpital)       1/n          1
lim --------- = lim --------      =     lim ------- = lim --- = 0
       n^2             n                       1           n

что означает n^2 растет быстрее, так n log(n) меньше (лучше), когда n достаточно высок.

23

хороший вопрос. На самом деле, я всегда показываю эти 3 снимка:

n = [0; 10]

enter image description here

n = [0; 100]

enter image description here

n = [0; 1000]

enter image description here

и O(N*log(N)) намного лучше, чем O(N^2). Это гораздо ближе к O(N), чем O(N^2).

но ваш O(N^2) алгоритм быстрее для N < 100 в реальной жизни. Есть много причин, почему это может быть быстрее. Возможно, из-за лучшего распределения памяти или других "не алгоритмических" эффектов. Может быть!--0--> алгоритм требует некоторой фазы подготовки данных или O(N^2) итерации короче. Во всяком случае, обозначение Big-O подходит только в случае достаточно больших Ns.

если вы хотите продемонстрировать, почему один алгоритм быстрее для небольших Ns, вы можете измерить время выполнения 1 итерации и постоянные накладные расходы для обоих алгоритмов, то используйте их, чтобы исправить теоретический сюжет:

пример

enter image description here

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

43

обозначение Big-O-это обозначение асимптотической сложности. Это означает, что он вычисляет сложность, когда N произвольно велико.

малых Н. С., много других факторов в. Возможно, что алгоритм имеет o(n^2) итераций цикла, но каждая итерация очень короткая, в то время как другой алгоритм имеет o (n) итераций с очень длинными итерациями. При больших Ns линейный алгоритм будет быстрее. При малых Ns квадратичный алгоритм будет быстрее.

Итак, для малых Ns просто измерьте два и посмотрите, какой из них быстрее. Нет необходимости входить в асимптотическую сложность.

кстати, не записывайте основу журнала. Обозначение Big-O игнорирует константы-O (17 * N) совпадает с O(N). Так как log2N просто ln N / ln 2, основой логарифма является еще одна константа и игнорируется.

14

давайте сравним их,

С одной стороны у нас есть:

n^2 = n * n

С другой стороны у нас есть:

nlogn = n * log(n)

положить их бок о бок:

n * n    versus    n * log(n)

давайте разделим на n, который является общим термином, чтобы получить:

n    versus    log(n)

давайте сравним значения:

n = 10           log(n) ~ 2.3
n = 100          log(n) ~ 4.6
n = 1,000        log(n) ~ 6.9
n = 10,000       log(n) ~ 9.21
n = 100,000      log(n) ~ 11.5
n = 1,000,000    log(n) ~ 13.8

Итак, мы имеем:

n >> log(n) for n > 1

n^2 >> n log(n) for n > 1
7

во-первых, не совсем корректно сравнивать асимптотическую сложность, смешанную с ограничением N. То есть, я могу заявить:

  • O(n^2) медленнее, чем O(n * log(n)), потому что определение Big O notation будет n is growing infinitely.

  • в частности N можно сказать, какой алгоритм быстрее, просто сравнивая N^2 * ALGORITHM_CONSTANT и N * log(N) * ALGORITHM_CONSTANT, где ALGORITHM_CONSTANT зависит от алгоритма. Например, если мы пересекаем массив дважды, чтобы сделать нашу работу, асимптотическая сложность будет O(N) и ALGORITHM_CONSTANT будет 2.

также я хотел бы упомянуть, что O(N * log2N) Я полагаю, logariphm на основании 2 (log2N) на самом деле то же самое, что O(N * log(N)) из-за свойств logariphm.

1

У нас есть два способа сравнить два Algo - >первый способ очень просто сравнить и применить limit

T1(n)-Algo1

T2(n)=Alog2

  lim  (n->infinite) T1(n)/T2(n)=m

(i) Если m=0 Algo1 быстрее, чем Algo2

(ii) m=k оба одинаковы

(iii) m=бесконечный Algo2 быстрее

* Второй способ довольно прост, как по сравнению с 1-м там вы просто берете журнал обоих, но не neglet multi constant

             Algo 1=log n

             Algo 2=sqr(n)

             keep log n =x

             Any poly>its log


   O(sqr(n))>o(logn)
0