Các đặc điểm của thuật toán độ phức tạp thời gian

Đôi khi thật dễ dàng để xác định độ phức tạp thời gian của một thuật toán mà tôi kiểm tra nó một cách cẩn thận. Các thuật toán có hai vòng lặp lồng nhau của $N$ rõ ràng là $N^2$ . Thuật toán khám phá tất cả các kết hợp có thể có của $N$ nhóm trong hai giá trị rõ ràng $2^N$ .

Tuy nhiên tôi không biết làm thế nào để "phát" một thuật toán với $\Theta(N \log N)$ phức tạp. Một triển khai sáp nhập đệ quy, ví dụ, là một. Các đặc điểm chung của sáp nhập hoặc các thuật toán $\Theta(N \log N)$ khác sẽ cho tôi manh mối nếu tôi đang phân tích một thuật toán là gì?

Tôi chắc chắn rằng có nhiều hơn một cách thuật toán có thể có độ phức tạp , vì vậy bất kỳ và tất cả các câu trả lời đều được đánh giá cao. BTW Tôi đang tìm kiếm các đặc điểm chung và lời khuyên, không phải bằng chứng nghiêm ngặt.$\Theta(N \log N)$

Archetypical bạn là một phân chia-và-chinh phục thuật toán, mà phân chia (và tái kết hợp) làm việc trong thời gian tuyến tính và recurses qua miếng. Merge sort hoạt động theo cách đó: chi tiêu O ( n ) thời gian tách đầu vào thành hai mảnh tương đương, đệ quy loại từng mảnh, và dành Θ ( n ) thời gian kết hợp hai sắp xếp nửa.$\Theta(n \log n)$$O(n)$$\Theta(n)$

Theo trực giác, tiếp tục ý tưởng phân chia và chinh phục, mỗi giai đoạn phân chia tổng thời gian tuyến tính, bởi vì sự gia tăng số lượng các mảnh để phân chia chính xác phù hợp với sự giảm kích thước của các mảnh, vì thời gian phân chia là tuyến tính. Tổng thời gian chạy là sản phẩm của tổng chi phí của một giai đoạn phân chia nhân với số lượng các giai đoạn phân chia. Vì kích thước của các mảnh được giảm một nửa mỗi lần, có các giai đoạn phân chia , do đó tổng thời gian chạy là n ⋅ log ( n $\log_2(n)$$n \cdot \log(n)$ . (Lên đến hằng số nhân, cơ sở của logarit là không liên quan.)

Đặt nó trong phương trình (), một trong những cách để ước tính thời gian chạy của một thuật toán như vậy là để thể hiện nó một cách đệ quy: T ( n ) = 2 T ( n / 2 ) + Θ ( n ) . Rõ ràng là thuật toán này mất nhiều thời gian hơn tuyến tính và chúng ta có thể thấy nhiều hơn nữa bằng cách chia cho n : T ( n $T(n)$$T(n) = 2 T(n/2) + \Theta(n)$$n$ Khinđôi,T(n)/ntăng một lượng không đổi:T(n)/ntăng theo hàm mũ, hay nói cách khác,T(n)=Θ(nlogn).

Đây là một ví dụ của một mẫu tổng quát hơn: định lý tổng thể . Đối với bất kỳ thuật toán đệ quy mà phân chia đầu vào của nó kích thước thành một mảnh kích thước n / b và mất một thời gian f ( n ) để thực hiện việc phân chia và tái tổ hợp, thời gian chạy đáp ứng T ( n ) = một ⋅ T ( n / b ) + f ( n ) . Điều này dẫn đến một dạng đóng phụ thuộc vào giá trị của a và b và hình dạng của$n$$a$$n/b$$f(n)$$T(n) = a \cdot T(n/b) + f(n)$$a$$b$ . Nếu$f$ và f ( n ) = Θ ( n ) , định lý chủ nói rằng T ( n ) = Θ ( n log n ) .$a = b$$f(n) = \Theta(n)$$T(n) = \Theta(n \log n)$

Two other categories of algorithms that take $\Theta(n \log n)$ time:

Algorithms where each item is processed in turn, and it takes logarithmic time to process each item (e.g. HeapSort or many of the plane sweep computational geometry algorithms).

Các thuật toán trong đó thời gian chạy bị chi phối bởi một bước xử lý trước sắp xếp. (Ví dụ: trong thuật toán của Kruskal cho cây bao trùm tối thiểu, chúng ta có thể sắp xếp các cạnh theo trọng lượng là bước đầu tiên).

Another category: Algorithms in which the output has size $\Theta(n \log n)$, and therefore $\Theta(n \log n)$ running time is linear in the output size.

Although the details of such algorithms often use divide-and-conquer techniques, they don't necessarily have to. The run-time fundamentally comes from the question being asked, and so I think it is worth mentioning separately.

This comes up in data structures which are based on an augmented binary search tree, where each node stores a linear size data structure to search over the leaves in that node's subtree. Such data structures come up often in geometric range searching, and are often based on a decomposition scheme. See Agarwal's Survey.

For a concrete example, consider the range-tree, built to answer two dimensional orthogonal range queries. Although the space was later reduced using some compression techniques to pack multiple objects into a single word, the textbook (and most intuitive) version of the data structure requires $O(n \log n)$ space (each leaf is stored in an auxiliary structure at each node on the path from the leaf to the root, or in $O(\log n)$ places), and the construction algorithm takes time linear in the space requirement.

A complexity of $O(n\log n)$ arises from divide and conquer algorithms which divide their input into $k$ pieces of roughly equal size in time $O(n)$, operate on these pieces recursively, and then combine them in time $O(n)$. If you only operate on some of the pieces, the running time drops to $O(n)$.

Those are typically algorithms of the "divide and conquer" variety, where the cost of dividing and combining subsolutions isn't "too large". Take a look at this FAQ to see what kinds of recurrences give rise to this behaviour.

Typically, Divide-and-conquer algorithms will yield O(N log N) complexity.

A generic example of a loop (not an algorithm per se) that runs in $O(n \log n)$ is the following:

for (i = 0; i < constant; i++){
    for(j = 0; j < n; j++){
        // Do some O(1) stuff on the input
    }
}

// Alternative Variant:
for (i = 0; i < constant; i++){
    for(j = n; j < constant; j++){
        // Do some O(1) stuff on the input
    }
}

(note that this nested loops are not $O(n^2)$. Also note that it isn't divide-and-conquer nor recursive.)

I can't give a concrete example of an algorithm that uses this loop, but it comes up often when coding custom algorithms.