Erklären Sie die Art der Blase
user
Bubble sortieren ist ein Sortieralgorithmus, um Arrays von Zahlen oder anderen vergleichbaren Dingen zu sortieren. Es funktioniert, indem zwei Elemente, die nebeneinander liegen, ausgetauscht werden, so dass der größere nach rechts ist. Dieser Prozess wird für jede Position von links nach rechts wiederholt. Danach ist die größte Zahl im Array an der letzten Position. Als nächstes beginnt der Algorithmus ganz links und wechselt Nachbarn nach rechts, aber dieses Mal kann er vor der letzten Position anhalten, da die größte Zahl bereits da ist. Es wird Bubble sortieren als die größte Zahl immer "Bubbles" oben. Hier ist ein Beispiel: `` 4 6 1 8 # swap 4, 3 4 6 1 8 # don't swap 4, 6 als 6 > 4 4 4 6 6 # swap 1, 6 6 # swap 8, 6 4 4 6 # swap 8, 1; 8 ist jetzt korrekt 4 6 # swap 4 1 8 # swap 4 6 # swap 4 6 # swap 4 6 # swap 4 6 # swap 8 # swap 8 # 3 6 # swap 8 # swap 8 # swap 8
assistant
Erklären Sie Haufen sortieren und häufen.
user
**Heap Sort** Heap Sort ist ein effizienter Sortieralgorithmus als Blasensortierung, der auch Zahlen oder andere ähnlich vergleichbare Dinge sortiert. Es verwendet einen Heap, (kann max oder min sein), der ein binärer Baum ist, bei dem ein Knoten immer größer oder kleiner ist als seine beiden Kinder. Es dauert `n*log_2(n)` Zeit, um den Heap zu erstellen, da jedes Element eingefügt werden muss, und kann auf maximal `log_2(n)` Ebenen des Baumes reisen. Dann ist der Wurzelknoten bereits max, so dass er herausgenommen und in einer sortierten Liste platziert werden kann.Dann wird ein Blattknoten gesetzt, wo sich der Wurzelknoten befindet, und der Baum wird neu sortiert, was höchstens `log_2(n)` Zeit benötigt. Dann wird der Wurzelknoten herausgenommen und wieder in die sortierte Liste gesetzt. Dieser Vorgang wird wiederholt, bis der Baum leer ist, was insgesamt `n*log_2(n)` Zeit braucht. Hier ist ein Beispiel, das 3 Zahlen sortiert: ``` ####################################################################################################################################################################################################################################################################### # (7) 2 ###################################### # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #Max Heap? Sind alle Child Nodes weniger als ihre Elternknoten? Ja. 9 # zum nächsten Blattknoten neun hinzufügen: # 7 # ├╝einem 9 # Sind alle Child Nodes weniger als ihre Elternknoten? Nein. # neun nach oben verschieben: # 9 # ├╝einem 2 # ├╝einem 7 # Sind alle Child Nodes weniger als ihre Elternknoten? Ja. # Es sind keine weiteren Elemente mehr übrig. Heap wird erzeugt. ####################################### # Nun vom Haufen sortieren. # ############################# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #  #der letzte Blatt-Node: # 7 #               ─ 2 # Sind alle Kind-Nodes weniger als ihre Eltern-Nodes? Ja. # nehmen Sie den Wurzel-Node und legen Sie ihn in die Liste links: # - # -        ─ 2 7 9 # ersetzen Sie den Wurzel-Node durch den letzten Blatt-Node: # (2) # Sind alle Kind-Nodes weniger als ihre Eltern-Nodes? Ja. # nehmen Sie den Wurzel-Node und legen Sie ihn in die Liste links: # (_) 2 7 9 # Der Baum ist leer, was bedeutet, dass wir fertig sind, sortieren! ``` --- **Heapify** Anstatt sich in der Haufen-Erstellung wie zuvor nach oben einzustellen, sieht der Haufen anjeder Knoten, beginnend mit dem rechten Blattknoten, und geht nach links, bis er etwas erreicht, das kein Haufen ist. Sobald er einen Knoten erreicht, wo die Kinder nicht alle kleiner als der Eltern sind, schaltet er den Wert der Wurzel mit dem größten Kind aus. Dies wird mit dem getauschten Kindknoten wiederholt, bis er den Boden des Baumes erreicht hat. Dann wird dieser ganze Prozess wiederholt, bis die Wurzel des gesamten Baumes erreicht ist. Dieser Prozess dauert immer noch maximal `n*log_m(n)` Zeit, wenn alle Elemente sich bewegen müssen.Hier ist ein Beispiel mit einem binären Baum mit vier Elementen: ``` # Beginnen Sie mit einem nicht max-Häufe binären Baum: 2 # 9 ist kein Haufen, denn 11 ist größer. Swap. 2 # 11 ist ein Haufen, weil er keine Kinder hat, weiter zu 7 # 7 ist ein Haufen, weil er keine Kinder hat, weiter zu 9 # 9 ist kein Haufen, weil 11 größer ist. Swap. 2 # 11 ist größer. Swap. 9 # 9 ist jetzt ein Haufen. Weiter zu 2. # 2 ist kein Haufen. Beide 11 und 7 sind größer. Swap mit 11da ist es am höchsten: 11 Uhr 2 Uhr 9 Uhr 7 Uhr 2 Uhr ist immer noch kein Haufen. Tausch mit 9 Uhr 11 Uhr 9 Uhr 2 Uhr 7 Uhr 2 Uhr ist ein Haufen, und 11 Uhr ist die Wurzel. Wir sind fertig! ```
assistant