Thuật toán: Làm thế nào để tôi tổng hợp O (n) và O (nlog (n)) với nhau?

Tôi có thuật toán theo sau để tìm các bản sao và loại bỏ chúng:

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;
}

Tôi đang cố gắng tìm ra sự phức tạp thời gian trường hợp xấu nhất của điều này. Tôi biết sự hợp nhất là nlog(n)và trong vòng lặp for của tôi, tôi đang lặp lại toàn bộ tập dữ liệu để được tính là n. Tôi không chắc phải làm gì với những con số này mặc dù. Tôi có nên tổng hợp chúng lại với nhau? Nếu tôi làm điều đó, tôi sẽ làm thế nào?

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

Đối với sự phức tạp của Big O, tất cả những gì bạn quan tâm là thuật ngữ chi phối. n log(n)thống trị nvì vậy đó là thuật ngữ duy nhất mà bạn quan tâm.

Hãy lý do theo cách của chúng tôi thông qua nó và nhớ định nghĩa của O. Cái tôi sẽ sử dụng là cho giới hạn ở vô cực.

Bạn đã đúng khi tuyên bố rằng bạn thực hiện hai thao tác với giới hạn tiệm cận tương ứng O(n)và O(nlog(n))nhưng kết hợp chúng thành một ràng buộc không đơn giản như thêm hai hàm. Bạn biết chức năng của bạn mất ít nhất O(n)thời gian và ít nhất là O(nlog(n))thời gian. Vì vậy, thực sự lớp phức tạp cho chức năng của bạn là sự kết hợp của O(n)và O(nlog(n))nhưng O(nlog(n))là một siêu khối của O(n)vì vậy thực sự nó là như vậy O(nlog(n)).

Nếu bạn định đặt nó ra từ lâu thì nó sẽ trông giống như thế này:

Giả sử tổng thời gian là: an + bn log (n), trong đó a và b là hằng số (bỏ qua các điều khoản bậc thấp hơn).

Khi n đi đến vô cùng (an + bn log (n)) / n log (n) -> a / log (n) + b -> b

Vậy tổng thời gian là O (bn log (n)) = O (n log (n)).

Bắt đầu với định nghĩa của O ():

O (n log n) có nghĩa là "nhỏ hơn C n log n, nếu n lớn".

O (n) có nghĩa là "nhỏ hơn D n, nếu n lớn".

Nếu bạn thêm cả hai, kết quả nhỏ hơn C n log n + D n <C n log n + D n log n <(C + D) n log n = O (n log n).

Nói chung, nếu f (n)> C g (n) cho n lớn và một số C> 0, thì O (f (n)) + O (g (n)) = O (f (n)). Và sau khi thực hiện một vài trường hợp sử dụng định nghĩa của O (), bạn sẽ biết những gì bạn có thể và không thể làm.

Ký hiệu O lớn được định nghĩa là một tập hợp:

Vì vậy, chứa tất cả các hàm - bắt đầu từ một số điểm lớn tùy ý - luôn nhỏ hơn g.

Bây giờ, khi bạn có một hàm nằm trong và sau đó thực thi một hàm khác tăng chậm hơn g thì chắc chắn là tăng chậm hơn 2g. Vì vậy, thực thi bất cứ điều gì chậm hơn g sẽ không thay đổi lớp phức tạp.

Chính thức hơn:

Bạn có thể dễ dàng chứng minh điều đó.

TL; DR

Nó vẫn còn