Y a-t-il un tas stable?

Existe-t-il une structure de données de file d'attente prioritaire qui prend en charge les opérations suivantes?

• Insérer (x, p) : ajouter un nouvel enregistrement x avec la priorité p
• StableExtractMin () : Renvoie et supprime l'enregistrement avec une priorité minimale, rompant les liens par ordre d'insertion .

Ainsi, après Insert (a, 1), Insert (b, 2), Insert (c, 1), Insert (d, 2), une séquence de StableExtractMin retournerait a, puis c, puis b, puis d.

Évidemment, on pourrait utiliser n'importe quelle structure de données de file d'attente prioritaire en stockant la paire comme priorité réelle, mais je suis intéressé par les structures de données qui ne stockent pas explicitement les temps d'insertion (ou l'ordre d'insertion), par analogie avec un tri stable .$(p, time)$

De manière équivalente (?): Existe-t-il une version stable de heapsort qui ne nécessite pas d' espace supplémentaire ?$\Omega(n)$

La méthode Bently-Saxe donne une file d'attente prioritaire stable assez naturelle.

Stockez vos données dans une séquence de tableaux triés . a une taille . Chaque tableau maintient également un compteur . Les entrées de tableau contiennent des données.A i 2 i c i A i [ c i ] , … , A i [ 2 i - 1 $A_0,\ldots,A_k$$A_i$$2^i$$c_i$$A_i[c_i],\ldots,A_i[2^i-1]$

Pour chaque , tous les éléments de ont été ajoutés plus récemment que ceux de et au sein de chaque éléments sont classés par valeur, les liens étant rompus en plaçant les éléments plus anciens devant les éléments plus récents. Notez que cela signifie que nous pouvons fusionner et et conserver cet ordre. (En cas d'égalité lors de la fusion, prenez l'élément de .)A i A i + 1 A i A i A i + 1 A i + $i$$A_i$$A_{i+1}$$A_i$$A_i$$A_{i+1}$$A_{i+1}$

Pour insérer une valeur , recherchez le plus petit tel que contienne 0 élément, fusionnez et , stockez-le dans et définissez manière appropriée.i A i A 0 , … , A i - 1 x A i c 0 , … , c $x$$i$$A_i$$A_0,\ldots,A_{i-1}$$x$$A_i$$c_0,\ldots,c_i$

Pour extraire le min, trouver le plus grand indice tel que le premier élément dans soit minimum sur tout et incrémenter .A i [ c i ] i c $i$$A_i[c_i]$$i$$c_i$

Par l'argument standard, cela donne temps amorti par opération et est stable en raison de l'ordre décrit ci-dessus.$O(\log n)$

Pour une séquence de insertions et extractions, cela utilise n entrées de tableau (ne conservez pas de tableaux vides) plus O ( log n ) mots de données de comptabilité. Cela ne répond pas à la version de Mihai de la question, mais cela montre que la contrainte stable ne nécessite pas beaucoup d'espace au-dessus. En particulier, cela montre qu'il n'y a pas de borne inférieure Ω ( n ) sur l'espace supplémentaire nécessaire.$n$$n$$O(\log n)$$\Omega(n)$

Mise à jour: Rolf Fagerberg souligne que si nous pouvons stocker des valeurs nulles (non-données), alors toute cette structure de données peut être compressée dans un tableau de taille , où n est le nombre d'insertions jusqu'à présent.$n$$n$

Tout d'abord, notez que nous pouvons regrouper les dans un tableau dans cet ordre (avec A k en premier, suivi de A k - 1 s'il n'est pas vide, etc.). La structure de ceci est complètement codée par la représentation binaire de n , le nombre d'éléments insérés jusqu'à présent. Si la représentation binaire de n a un 1 à la position i , alors A i occupera 2 i emplacement de tableau, sinon il n'occupera aucun emplacement de tableau.$A_k,\ldots,A_0$$A_k$$A_{k-1}$$n$$n$$i$$A_i$$2^i$

Lors de l'insertion, et la longueur de notre tableau, augmentez de 1 et nous pouvons fusionner A 0 , … , A i plus le nouvel élément en utilisant des algorithmes de fusion stables en place existants.$n$$A_0,\ldots,A_i$

Maintenant, où nous utilisons des valeurs nulles, c'est pour se débarrasser des compteurs . Dans A i , nous stockons la première valeur, suivie de c i valeurs nulles, suivie des 2 i - c i - 1 valeurs restantes . Lors d'une extraction-min, on peut toujours trouver la valeur à extraire en temps O ( log n ) en examinant A 0 [ 0 ] , … , A k [ 0 ] . Lorsque nous trouvons cette valeur dans A i [ $c_i$$A_i$$c_i$$2^i-c_i-1$$O(\log n)$$A_0[0],\ldots,A_k[0]$ nous définissons A i [ 0 ] sur null puis effectuons une recherche binaire sur A i pour trouver la première valeur non nulle A i [ c i ] et permutons A i [ 0 ] et A i [ c i ] .$A_i[0]$$A_i[0]$$A_i$$A_i[c_i]$$A_i[0]$$A_i[c_i]$

Le résultat final: la structure entière peut être implémentée avec un tableau dont la longueur est incrémentée à chaque insertion et un compteur, , qui compte le nombre d'insertions.$n$

Je ne sais pas quelles sont vos contraintes; les éléments suivants sont-ils admissibles? Stockez les données dans un tableau, que nous interprétons comme un arbre binaire implicite (comme un tas binaire), mais avec les éléments de données au niveau inférieur de l'arbre plutôt qu'à ses nœuds internes. Chaque nœud interne de l'arbre stocke la plus petite des valeurs copiées de ses deux enfants; en cas d'égalité, copiez l'enfant de gauche.

Pour trouver le minimum, regardez la racine de l'arbre.

Pour supprimer un élément, marquez-le comme supprimé (suppression paresseuse) et propagez l'arborescence (chaque nœud sur le chemin d'accès à la racine qui contenait une copie de l'élément supprimé doit être remplacé par une copie de son autre enfant). Conservez un décompte des éléments supprimés et si jamais il devient trop grand une fraction de tous les éléments, puis reconstruisez la structure en préservant l'ordre des éléments au niveau inférieur - la reconstruction prend du temps linéaire, donc cette partie n'ajoute qu'un temps amorti constant à la complexité de l'opération.

Pour insérer un élément, ajoutez-le à la position libre suivante sur la ligne inférieure de l'arborescence et mettez à jour le chemin d'accès à la racine. Ou, si la ligne du bas devient pleine, doublez la taille de l'arborescence (à nouveau avec un argument d'amortissement; notez que cette partie n'est pas différente de la nécessité de reconstruire lorsqu'un tas binaire standard dépasse son tableau).

Ce n'est pas une réponse à la version plus stricte de la question de Mihai, car elle utilise deux fois plus de mémoire qu'une véritable structure de données implicite, même si nous ignorons le coût d'espace de gestion des suppressions paresseusement.

Est-ce une interprétation valide de votre problème:

Vous devez stocker N clés dans un tableau de A [1..N] sans informations auxiliaires telles que vous pouvez prendre en charge: * insérer la clé * supprimer min, qui sélectionne l'élément inséré le plus tôt s'il existe plusieurs minima

Cela semble assez difficile, étant donné que la plupart des structures de données implicites jouent le rôle de codage des bits dans l'ordre local de certains éléments. Ici, si plusieurs gars sont égaux, leur ordre doit être préservé, donc de telles astuces ne sont pas possibles.

Intéressant.

Réponse courte: vous ne pouvez pas.

Réponse légèrement plus longue:

$\Omega(n)$$\Omega(n)$

$addr(X) < addr(Y)$

Réponse très longue avec des pseudo-mathématiques floues inexactes:

Remarque: la toute fin de la deuxième partie est sommaire, comme mentionné. Si un mathématicien pouvait fournir une meilleure version, je lui en serais reconnaissant.

$P$

$(a,1) < (a,2)$$(a,1) = (a,1)$$(a,1)$$(b,1)$

$X < Y$$X$$Y$

$(?,1)$$?$

• $X - log_2(P)$$2^X$
• $P$

$X - log_2(P)$$O(n)$$n$

Maintenant, combien de bits d'informations chaque «cellule» de mémoire nous fournit-elle?

• $W$$W$
• $X$

$P \geq 1$$X - log_2(P) < X$

Ainsi, pour stocker toutes nos informations, nous avons deux possibilités:

• Stockez l'ordre d'insertion dans l'adresse et la charge utile en mémoire.
• Stockez les deux en mémoire et laissez l'adresse libre pour une autre utilisation.

Évidemment, pour éviter le gaspillage, nous utiliserons la première solution.

Maintenant pour les opérations. Je suppose que vous souhaitez avoir:

• $Insert(task, priority)$$O(log n)$
• $StableExtractMin()$$O(log n)$

$StableExtractMin()$

L'algorithme vraiment vraiment général se présente comme suit:

1. $O(log n)$
2. $O(log n)$
3. Rends le.

$0(1)$$O(1)$$O(1)$

$O(log n)$$2^(X - log_2(P))$

$X - log_2(P)$$O(log n)$$O(log n)$

$O(log n)$

$O(log n)$$X - log_2(P)$

$O(log n)$

$X - log_2(P)$$O(log n)$

L'algorithme d'insertion a généralement juste besoin de mettre à jour une partie de ces informations, je ne pense pas que cela coûtera plus cher (en termes de mémoire) de le faire fonctionner rapidement.

$X - log_2(P)$

• $X - log_2(P)$
• $P$
• $X - log_2(P)$

$\Omega(n)$

Si vous implémentez votre file d'attente prioritaire en tant qu'arbre binaire équilibré (un choix populaire), il vous suffit de vous assurer que lorsque vous ajoutez un élément à l'arborescence, il est inséré à gauche de tous les éléments de priorité égale.
De cette façon, l'ordre d'insertion est codé dans la structure de l'arbre lui-même.

Je ne pense pas que ce soit possible

cas concret:

       x
    x    x
  x  x  1  x
1  x  

tas minimum avec tous les x> 1

heapifying donnera finalement quelque chose comme un choix

       x
    1    1
  x  x  x  x
x  x  

maintenant lequel 1 se propager à root?