Tri à l'aide d'une boîte noire

Supposons que nous voulons trier une liste de n nombres réels. Supposons que l'on nous donne une boîte noire qui peut trier $S$$n$ nombres réels instantanément. Quel avantage pouvons-nous gagner en utilisant cette boîte noire?$\sqrt n$

Par exemple, pouvons-nous trier les nombres avec seulement appels à la boîte noire? Le meilleur algorithme que j'ai trouvé utilisenappels à la boîte noire. Mais je n'ai pas pu l'améliorer davantage. Voici mon algorithme qui est similaire au tri par fusion:$O(\sqrt n)$$n$

Première partition de la liste en $S$ listess1,s2,. . . ,s$\sqrt n$ avec environ$s_1, s_2, ..., s_{\sqrt n}$taille n . Utilisez ensuite$\sqrt n$ appelle la boîte noire pour trier ces listes. Enfin, fusionnez les listes triées à l'aide de la boîte noire comme suit:$\sqrt n$

Mettez les plus petits éléments des listes dans une nouvelle liste , puis appelez la boîte noire pour la trier. Le nombre de L [ 1 ] (premier et plus petit élément de L ) sera le plus petit nombre dans S . Nous pouvons le mettre à la première place de la liste de sortie. En supposant que l'élément a été choisi parmi les s j , on remplace L [ 1 ] avec le deuxième plus petit élément de la liste de tri de j , et d' exécuter à nouveau la boîte noire sur elle pour calculer le deuxième plus petit élément de S .$L$$L[1]$$L$$S$
$s_j$$L[1]$$s_j$$S$
Nous continuons jusqu'à ce que tous les éléments soient triés. Le nombre total d'appels en boîte noire pour cette partie sera . Par conséquent, dans l'ensemble, le nombre total d'appels seran.$n - \sqrt n$$n$

D'un autre côté, il semble que nous devrions pouvoir obtenir une borne inférieure en utilisant la borne inférieure sur les comparaisons de nombres nécessaires pour le tri comme suit: Nous pouvons implémenter la boîte noire en utilisant comparaisons. Si nous pouvons résoudre le problème aveco($\sqrt n \lg \sqrt n = \frac{1}{2} \sqrt n \lg n$appels à la boîte noire et en fusionnant en temps linéaire on peut triernnombres réels avec descomparaisonso(nlgn)ce qui est impossible.$o(\sqrt n)$$n$$o(n \lg n)$

Je suppose que nous pourrions prouver que est une limite inférieure pour le nombre d'appels à la boîte noire, car de nombreuses comparaisons utilisant dans la boîte noire seraient partagées et sont donc racontées dans notre argument.$\Omega(n)$

MISE À JOUR: Comme le suggèrent les autres articles, un est également réalisable.$\sqrt n \lg n$

Il est possible de trier avec appels à la boîte noire et aucune comparaison.$O(\sqrt n\log n)$

Considérons d'abord le problème de partitionnement équilibré suivant: étant donné éléments A [ 1 .. m ] (où $m$$A[1..m]$), divisez-les en deux groupes, le plus petit de taille au moins environm/4, de sorte que tous les éléments du premier groupe soient plus petits que tous les éléments du deuxième groupe. Cela peut être fait avecO(m/$\sqrt n \le m \le n$$m/4$appels à la boîte noire. (Je le décrirai plus tard.) Utilisez ensuite quicksort avec cet algorithme de partitionnement:$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.

En supposant que chaque étape de partition prend appels à la boîte noire, l'algorithme ci-dessus, étant donné l'entréeA[1 ..n], feraO($O(m/\sqrt n)$$A[1..n]$ appelle la boîte noire, car l'arbre de récursivité a la profondeur O ( log n ) et chaque niveau de l'arbre a un total de O ( n / $O(\sqrt n\log n)$$O(\log n)$appels à la boîte noire.$O(n/\sqrt n) = O(\sqrt n)$

Effectuez l'étape de partitionnement comme suit:

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.)

Je pense que votre question a été abordée dans l'article de Beigel et Gill " Tri d'objets n à l'aide de k-sorter " de 1990 et le résumé de l'article dit tout:

et$\frac{n \log n}{k \log 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$ tri à la place d'une opération de comparaison-échange. La correction s'ensuit en observant que le réseau trie correctement tout tableau de 0 et de 1 .

$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)$