Bonjour à tous,
J'essaie de créer l'algorithme de tri rapide pour des listes liées similaires à cet exemple, mais j'ai quelques problèmes. Je me rends compte que les listes chaînées ont des structures de mémoire différentes de celles des tableaux et qu'il peut être difficile de les diviser efficacement.
Voici ce que j'ai en Python jusqu'à présent
Code :
- class ListNode:
- def __init__(self, val=0, next=None):
- self.val = val
- self.next = next
- def quick_sort_linked_list(head):
- if not head or not head.next:
- return head
- pivot = head
- smaller_head = smaller_tail = None
- equal_head = equal_tail = None
- larger_head = larger_tail = None
- current = head.next
- while current:
- if current.val < pivot.val:
- if not smaller_head:
- smaller_head = smaller_tail = current
- else:
- smaller_tail.next = current
- smaller_tail = current
- elif current.val == pivot.val:
- if not equal_head:
- equal_head = equal_tail = current
- else:
- equal_tail.next = current
- equal_tail = current
- else:
- if not larger_head:
- larger_head = larger_tail = current
- else:
- larger_tail.next = current
- larger_tail = current
- current = current.next
- # Recursively sort the smaller and larger partitions
- smaller_sorted = quick_sort_linked_list(smaller_head)
- larger_sorted = quick_sort_linked_list(larger_head)
- # Combine the partitions in the correct order
- result_head = result_tail = ListNode(None)
- if smaller_sorted:
- result_tail.next = smaller_sorted
- result_tail = smaller_tail
- if equal_head:
- result_tail.next = equal_head
- result_tail = equal_tail
- if larger_sorted:
- result_tail.next = larger_sorted
- return result_head.next
- # Example usage
- head = ListNode(38)
- head.next = ListNode(27)
- head.next.next = ListNode(43)
- head.next.next.next = ListNode(3)
- head.next.next.next.next = ListNode(9)
- head.next.next.next.next.next = ListNode(82)
- head.next.next.next.next.next.next = ListNode(10)
- sorted_head = quick_sort_linked_list(head)
|
Quelqu'un pourrait-il expliquer les différentes procédures de sélection de pivot dans Quick Sort, telles que choisir le premier, le dernier, la médiane de trois ou un élément aléatoire ? De plus, comment puis-je m'assurer que mon choix de pivot réduit le risque de complexité temporelle dans le pire des cas ?
Tout exemple ou visualisation du processus de sélection de pivot serait grandement apprécié. Merci pour votre aide!