Saya memiliki algoritma ikuti yang menemukan duplikat dan menghapusnya:
public static int numDuplicatesB(int[] arr) {
Sort.mergesort(arr);
int numDups = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i] == arr[i - 1]) {
numDups++;
} }
return numDups;
}
Saya mencoba untuk menemukan kompleksitas waktu kasus terburuk ini. Saya tahu mergesort adalah nlog(n)
, dan dalam loop saya, saya mengulangi seluruh set data sehingga akan dihitung sebagai n
. Saya tidak yakin apa yang harus dilakukan dengan angka-angka ini. Haruskah saya menjumlahkannya bersama? Jika saya melakukan itu, bagaimana saya melakukannya?
algorithms
algorithm-analysis
big-o
chopper draw lion4
sumber
sumber
Jawaban:
Untuk kompleksitas O Besar, semua yang Anda pedulikan adalah istilah dominan.
n log(n)
mendominasin
sehingga itulah satu-satunya istilah yang Anda pedulikan.sumber
f(n) is O(g(n))
apa yang sebenarnya kita katakan adalah fungsinyaf is a member of the set of functions that grows at the rate of at most g(n) over the long term
. Ini berarti semua anggotaO(n)
juga anggotaO(n*log(n))
. The+
dalam ekspresi sukaO(f(n)) + O(g(n))
sebenarnya merujuk ke set union (yang dari Anda benar-benar bertele-tele, Anda benar-benar harus menggunakan ∪).A + B = { a + b | a in A, b in B }
. Itu terjadi bahwa untuk set formulirO(g(n))
ini sama dengan set union, karena salah satu set selalu merupakan subset dari yang lain, dan mereka berdua tidak sama dengan jumlah (yaitu A + A = A). (Ups, Nate memang menulis dasarnya sama).Mari kita pikirkan jalan kita melaluinya dan ingat definisi
O
. Yang akan saya gunakan adalah untuk batas tak terbatas.Anda benar dalam menyatakan bahwa Anda melakukan dua operasi dengan batas asimtotik yang sesuai
O(n)
danO(nlog(n))
tetapi menggabungkannya ke dalam satu ikatan tidak sesederhana menambahkan kedua fungsi tersebut. Anda tahu fungsi Anda membutuhkan setidaknyaO(n)
waktu dan juga setidaknyaO(nlog(n))
waktu. Jadi sebenarnya kelas kompleksitas untuk fungsi Anda adalah penyatuanO(n)
danO(nlog(n))
tetapiO(nlog(n))
merupakan superset dariO(n)
begitu benar-benar adilO(nlog(n))
.sumber
Jika Anda akan menetapkannya dengan tangan itu akan terlihat kira-kira seperti ini:
Misalkan total waktu adalah: log + bn (n), di mana a dan b adalah konstanta (mengabaikan syarat urutan lebih rendah).
Saat n menuju tak terhingga (log + bn (n)) / n log (n) -> a / log (n) + b -> b
Jadi total waktu adalah O (bn log (n)) = O (n log (n)).
sumber
Mulai dengan definisi O ():
O (n log n) berarti "kurang dari C n log n, jika n besar".
O (n) berarti "kurang dari D n, jika n besar".
Jika Anda menambahkan keduanya, hasilnya kurang dari C n log n + D n <C n log n + D n log n <(C + D) n log n = O (n log n).
Secara umum, jika f (n)> Cg (n) untuk n besar dan beberapa C> 0, maka O (f (n)) + O (g (n)) = O (f (n)). Dan setelah melakukan beberapa kasus menggunakan definisi O (), Anda akan tahu apa yang bisa dan tidak bisa Anda lakukan.
sumber
Notasi O besar didefinisikan sebagai satu set:
Jadi berisi semua fungsi yang - mulai dari titik besar sembarang - selalu lebih kecil dari g.
Sekarang, ketika Anda memiliki fungsi yang ada di dalam dan kemudian jalankan fungsi lain yang meningkatkan lebih lambat daripada g itu tentu saja meningkat lebih lambat dari 2g. Jadi mengeksekusi sesuatu yang lebih lambat daripada g tidak akan mengubah kelas kompleksitas.
Lebih formal:
Anda dapat dengan mudah membuktikannya.
TL; DR
Ini masih
sumber