Sắp xếp bằng hộp đen

Giả sử rằng chúng ta muốn sắp xếp một danh sách gồm số thực. Giả sử rằng chúng ta được cung cấp một hộp đen có thể sắp xếp số thực ngay lập tức. Chúng ta có thể đạt được bao nhiêu lợi thế khi sử dụng hộp đen này?$S$$n$$\sqrt n$

Ví dụ: chúng ta có thể sắp xếp các số chỉ với các lệnh gọi vào hộp đen không? Thuật toán tốt nhất mà tôi đã tìm thấy sử dụng cuộc gọi đến hộp đen. Nhưng tôi đã không thể cải thiện nó hơn nữa. Đây là thuật toán của tôi tương tự như merge-sort:$O(\sqrt n)$$n$

Đầu tiên phân vùng danh sách thành liệt kê với kích thước xấp xỉ . Sau đó sử dụng các cuộc gọi vào hộp đen để sắp xếp các danh sách này. Cuối cùng, hợp nhất các danh sách được sắp xếp bằng hộp đen như sau:$S$$\sqrt n$$s_1, s_2, ..., s_{\sqrt n}$$\sqrt n$$\sqrt n$

Đặt các phần tử nhỏ nhất của danh sách vào danh sách mới , sau đó gọi hộp đen để sắp xếp nó. Số trong (đầu tiên và phần tử nhỏ nhất của ) sẽ là số nhỏ nhất trong . Chúng ta có thể đặt nó ở vị trí đầu tiên của danh sách đầu ra. Giả sử phần tử đã được chọn từ , chúng ta thay thế với phần tử nhỏ nhất thứ hai trong danh sách loại , và một lần nữa chạy hộp đen trên sẽ được tính toán thành viên nhỏ thứ hai của . Chúng tôi tiếp tục cho đến khi tất cả các yếu tố được sắp xếp. Tổng số cuộc gọi hộp đen cho phần này sẽ là$L$$L[1]$$L$$S$
$s_j$$L[1]$$s_j$$S$
$n - \sqrt n$. Do đó, tổng số cuộc gọi sẽ là .$n$

Mặt khác, có vẻ như chúng ta sẽ có thể để có được một thấp-bound sử dụng thấp-bound trên so sánh số lượng cần thiết để phân loại như sau: Chúng ta có thể thực hiện các hộp đen sử dụng so sánhlgn. Nếu chúng ta có thể giải quyết vấn đề vớio($\sqrt n \lg \sqrt n = \frac{1}{2} \sqrt n \lg n$các cuộc gọi đến hộp đen và hợp nhất theo thời gian tuyến tính, chúng ta có thể sắp xếpnsố thực với các phépso sánho(nlgn)không thể thực hiện được.$o(\sqrt n)$$n$$o(n \lg n)$

Tôi đoán chúng ta có thể chứng minh rằng là giới hạn thấp hơn cho số lượng cuộc gọi đến hộp đen, vì rất nhiều phép so sánh sử dụng trong hộp đen sẽ được chia sẻ và do đó được kể lại trong lập luận của chúng tôi.$\Omega(n)$

UPDATE: Là các bài viết khác đề nghị, một cũng có thể đạt được.$\sqrt n \lg n$

Có thể sắp xếp với gọi đến hộp đen và không so sánh.$O(\sqrt n\log n)$

Đầu tiên, hãy xem xét các vấn đề phân vùng cân bằng sau: cho yếu tố A [ 1 .. m ] (nơi $m$$A[1..m]$), phân vùng chúng thành hai nhóm, kích thước nhỏ nhất ít nhất khoảngm/4, sao cho tất cả các phần tử trong nhóm thứ nhất nhỏ hơn tất cả các phần tử trong nhóm thứ hai. Điều này có thể được thực hiện vớiO(m/$\sqrt n \le m \le n$$m/4$các cuộc gọi đến hộp đen. (Tôi sẽ mô tả điều đó sau.) Sau đó, sử dụng quicksort với thuật toán phân vùng này:$O(m/\sqrt n)$

def qsort(A[1..m]):
   if m < sqrt(n): sort A with one call to the black box
   else:
     Partition A[1..m] into two groups as described above.
     Recursively qsort the first group.
     Recursively qsort the second group.

Giả sử mỗi bước phân vùng mất cuộc gọi đến hộp đen, các thuật toán trên, đưa đầu vàoMột[1 ..n], sẽ làm choO($O(m/\sqrt n)$$A[1..n]$cuộc gọi đến các hộp đen, bởi vì cây đệ quy có chiều sâuO(logn)và mỗi cấp độ của cây có tổng cộngO(n/$O(\sqrt n\log n)$$O(\log n)$các cuộc gọi đến hộp đen.$O(n/\sqrt n) = O(\sqrt n)$

Thực hiện bước phân vùng như sau:

def partition(A[1..m]):  (where sqrt(n) <= m <= n)
   Divide A into m/sqrt(n) groups of size sqrt(n) each.
   Sort each group with one call to the black box per group.
   Sort the medians of the groups with one call to the black box.
   (Note the number of groups is less than sqrt(n), because m <= n.)
   Let X be the median of the medians.
   Partition all m elements around X, using the black box as follows:
      For each group G, let Y be its median:
        Call the black box once on (G - {Y}) union {X}.
        (This gives enough information to order all elts w.r.t. X.)

Tôi nghĩ rằng câu hỏi của bạn đã được giải quyết trong bài viết của Beigel và Gill " Sắp xếp n đối tượng bằng cách sử dụng k-sorter " từ năm 1990 và bản tóm tắt của bài báo đã nói lên tất cả:

K-sorter là một thiết bị sắp xếp các đối tượng k theo đơn vị thời gian. Độ phức tạp của thuật toán sử dụng bộ sắp xếp k được định nghĩa là số lượng ứng dụng của bộ sắp xếp k. Trong biện pháp này, độ phức tạp của việc sắp xếp n đối tượng nằm giữa và4nlog$\frac{n \log n}{k \log k}$ , lên đến các điều khoản thứ nhất trong n và k.$\frac{4n \log n}{k \log k}$

$O(\sqrt{n}\log n)$$n$

$k$$\sqrt{n}$$2(n/k)^2$$k$$2n/k$

BlockBubbleSort(X[0..n-1], k):
   m = floor(n/k)
   for i = 1 to m
      for j = 0 to m-1
          BlackBoxSort(X[j*k .. (j+1)*k-1])
      for j = 0 to m-1
          BlackBoxSort(X[j*k + k/2 .. (j+1)*k + k/2 - 1])

$n=18$$k=4$$k$

$k/2$$k$

$O((n/k)^2)$$O((n/k)\log^2(n/k)) = O(\sqrt{n}\log^2 n)$$O((n/k)\log (n/k)) = O(\sqrt{n}\log n)$