Pourquoi la complexité de l'espace de fusion est O(log(n)) avec des listes liées?
Mergesort sur un tableau a une complexité d'espace de O (n), tandis que mergesort sur une liste liée a une complexité d'espace de O (log (n)), documenté ici
Je crois que je comprends le cas des baies, car nous avons besoin de stockage auxiliaire lors de la fusion des deux sous-baies. Mais un tri de fusion de liste liée ne fusionnerait-il pas simplement les deux listes sous-liées en place? Je pense que cela aurait une complexité d'espace O(1) pour créer une nouvelle tête.
Fusion sur place (pas de stockage auxiliaire):
public Node merge(Node a, Node b) {
Node dummyHead, curr; dummyHead = new Node(); curr = dummyHead;
while(a !=null && b!= null) {
if(a.info <= b.info) { curr.next = a; a = a.next; }
else { curr.next = b; b = b.next; }
curr = curr.next;
}
curr.next = (a == null) ? b : a;
return dummyHead.next;
}
Une explication serait formidable.
Mergesort est un algorithme récursif. Chaque étape récursive place une autre image sur la pile. Le tri de 64 éléments prendra une étape récursive de plus que 32 éléments, et c'est en fait la taille de la pile qui est mentionnée lorsque l'espace requis est dit O (log (n)).
L'algorithme de fusion est récursif, il nécessite donc un espace de pile O (log n), pour les cas de tableau et de liste liée. Mais le cas du tableau alloue également un espace supplémentaire O(n), qui domine l'espace O (log n) requis pour la pile. La version du tableau est donc O (n) et le lien la version de la liste est O (log n).