Diskussion:Heapsort

message: Beispielprogramme sind gut. Ev. auch noch in weiteren Programmiersprachen. (nicht signierter Beitrag von 62.203.10.24 (Diskussion | Beiträge) 00:27, 21. Jul. 2003 (CEST)
thread_title:  beispielprogramme 

message: Irgendwie finde ich, dass die beispielhaften Implementierungen langsam überhand nehmen. Würde es begrüßen, wenn wir uns auf eine Sprache einigen könnten (im Zweifelsfall eine Beschreibungssprache), anhand der sich der Algorithmus veranschaulichen lässt. --Kasper4711 09:14, 31. Okt. 2006 (CET)
replies: text: Das ist echt totaler Schmand. Laufzeit vom Quicksort n²? Der hat im Worstcase ne Laufzeit von n*log(n).
Ich habe auch beide Algorithmen implementiert. Quicksort war fast immer schneller. (nicht signierter Beitrag von Lukascho (Diskussion | Beiträge) 15:21, 7. Jul. 2007 (CEST)
replies: text: unbedingt die beispiele in verschiedenen programmiersprachen drinlassen. anfänger freuen sich, wenn sie den code mal fix reinkopieren können und gleich probieren und sehen, was passiert. was hilfreich wäre zur veranschaulichung wäre sicher noch der pseudocode (nicht signierter Beitrag von Fredfeuerstein (Diskussion | Beiträge) 03:22, 3. Jun. 2008 (CEST)
thread_title:  Zahl der Beispiel-Implementierungen 

message: Das folgende habe ich erstmal aus dem Artikel entfernt, weil der Code garnicht lauffähig ist.
(Zeilennummern und Hihilghts von mir hinzugefügt)
==Java 5==
Der beste Sortieralgorithmus mit konstanter Speicherkomplexität und einer Zeitkomplexität von n log n ist der komplizierteste. Er ahmt einen Binärbaum in der zu sortierenden Reihung durch Manipulierung der Indizes nach. Hierbei sind die zwei Nachfolger (im Sinne des Binärbaums) eines Elements mit dem Index i die beiden Elemente mit den Indizes 2i und 2i+1. Falls diese außerhalb der Reihungsgrenzen fallen, hat das Element keine Nachfolger (ist ein Blatt). Die Halde (heap) ist ein Abschnitt der Reihung (zwischen zwei Indizes), die die Haldenbedingung erfüllt. Im Heap Sort wird durch Austausch von Elementen zuerst eine Halde (von hinten nach vorne) aufgebaut und dann (von vorne nach hinten) abgebaut, indem die Spitze der Halde (das größte Element) mit dem hintersten ausgetauscht wird.
static class HeapSort<E> extends Comparable<E> {
   /* die Sequenz innerhalb von sammlung zwischen a und b erfüllt die
      Haldenbedingung, wenn für jedes i mit 2*i+1 <= b gilt
      (sofern 2*i und 2*i+1< sammlung.length-1):
      sammlung[i] > sammlung[2*i] && sammlung[i] > sammlung[2*i+1] */
   private void senken(E[] sammlung, int links, int rechts) {
      /* Die Halde zwischen links und rechts wird durch das Senken
         des Elements sammlung[links - 1] nach unten erweitert:
         Die Elemente zwischen links - 1 und rechts bilden eine Halde */
      int index = links - 1; // linke Grenze der neuen Halde
      int nachfolger = 2 * index; // linker Nachfolger
      final E zuSenken = sammlung[index];
      while (true) { // zwei Abbruchstellen
         if (nachfolger > rechts) break; // weil kein Nachfolger
         if (nachfolger < rechts && sammlung[nachfolger].compareTo(sammlung[nachfolger + 1]) < 0)
            // kleineren nachfolger oder nachfolger + 1 auswählen
            nachfolger ++;
            if (sammlung[nachfolger].compareTo(zuSenken) < 0) break; // weil Platz gefunden
            sammlung[index] = sammlung[nachfolger]; // hochrücken
            index = nachfolger; // nach unten gehen
            nachfolger = 2 * index; // linker Nachfolger, wenn existiert
         }
         sammlung[index] = zuSenken; // Element einfügen
   }
   public void heapSort(E[] sammlung) { // sammlung[0] ungenutzt
      /* Halde aufbauen; die obere Hälfte zwischen sammlung.length/2+1 und sammlung.length-1 erfüllt 
                                        die Haldenbedingung immer: */
      int rechts = sammlung.length-1;
      for (int links = rechts / 2 + 1; links > 1; links--) {
         // untere Hälfte einzeln hinzufügen
         senken(sammlung, links, rechts);
         // Elemente zwischen 1 und sammlung.length-1 erfüllen die Bedingung
         // Halde wird abgebaut, d.h. sammlung wird sortiert:
         final int links = 1; // sammlung[0] ungenutzt
         for (rechts = sammlung.length-1; rechts > links; rechts--) {
         // austauschen der äußeren Elemente:
         final E groesstesElement = sammlung[links]; // Spitze
         sammlung[links] = sammlung[rechts]; // hinteres Element nach vorne eintauschen
         sammlung[rechts] = groesstesElement; // Element nach hinten
         senken(sammlung, links + 1, rechts - 1); // Element senken
      }
   }
}
#(Zeile 1): Mit static class HeapSort<E> extends Comparable<E> war wohl eher static class HeapSort<E extends Comparable<E>> gemeint; ansonsten ergibt das keinen Sinn.
#(Zeile 34): links wird doch gerade durchgezählt!; warum wird es hier noch einmal initialisiert?
#(Zeile 35): Worauf bezieht sich die Schleife? -- sie wird nie geschlossen!
Ich hab` jetzt leider keine Zeit mich in den Code einzuarbeiten, um das zu korrigieren...
Grüße --Falk  Sprichzumir... 23:03, 21. Jul. 2008 (CEST)
thread_title:  [[Java (Programmiersprache)|Java 5]] -- Implementierung 

message: Guter Artikel,
ich kenne das (lt. Duden Informatik) allerdings als versinken und nicht als versickern. (nicht signierter Beitrag von 82.212.0.37 (Diskussion | Beiträge) 20:13, 9. Jul. 2004 (CEST)
replies: text: Wenn Objekte in einem mehr flüssigen Element einsinken, dann versinken sie. Ein Wassertropfen hingegen, versickert im Boden. Letzteres passt daher sehr gut, weil sich die kleineren Zahlen in der Array-Wurzel zwischen den größeren Zahlen nach unten bewegen. --Zahlenzauber (Diskussion) 20:57, 11. Jul. 2023 (CEST)
thread_title:  versinken vs. versickern 

message: Die übliche Vorgehensweise ist eigentlich, den Heap aufsteigend anzulegen. In der Wurzel also das kleinste und nicht das größte Element zu haben!! (nicht signierter Beitrag von 80.135.153.237 (Diskussion | Beiträge) 12:01, 11. Jul. 2004 (CEST)
replies: text: Ist aber zweckmäßig, wenn man den Heap in einem Array aufbaut, dann ist die Wurzel in A[0] und der Heap anfangs der Levelorder, danach wird die Wurzel immer mit dem letzen (aktuellen) Element des Arrays vertauscht. (nicht signierter Beitrag von 82.212.0.37 (Diskussion | Beiträge) 00:14, 31. Jul. 2004 (CEST)
thread_title:  aufsteigend 

message: Im Beispiel in der Funktion "heapSort" müssen die Nullen durch Einsen ersetzt werden!?! Ich dachte, wir benutzen ein Array, das bei 1 beginnt... --Kasper (falsch signierter Beitrag von 53.122.197.194 (Diskussion | Beiträge) 10:19, 29. Jun. 2005 (CEST)
replies: text: In Java (und den meisten anderen Programmiersprachen) beginnen Arrays bei 0. --Head  14:32, 6. Aug 2005 (CEST)
replies: text: Das ist mir wohl bekannt. Man bekommt aber glaub' Probleme, wenn man mit Index = 0 arbeitet, insbesondere passt da die Berechnung der Nachfolger nicht mehr. Das Array muss dann halt mit max_index+1 deklariert werden, wenn man mit einem verschenkten Slot leben kann. IMHO ist das Beispiel falsch, so wie es dasteht. --Kasper4711 20:42, 6. Aug 2005 (CEST)

text: Habe das Beispiel jetzt mal korrigiert, nachdem seit langem kein weiterer Einwand gekommen ist. Wer doch vom Gegenteil überzeugt ist, soll mir dann aber bitte erklären, wie man für index == 0 bei nachfolger = 2*index einen Nachfolger des Elements erhält. --Kasper4711 09:52, 6. Feb 2006 (CET)
replies: text: Zum Beispiel mit index=0 nachfolger = 2*(index+1)-1, nachfolger2 = 2*(index+1) - Ntr0pY (nicht signierter Beitrag von 193.138.91.175 (Diskussion | Beiträge) 11:34, 20. Mär. 2006 (CET)
replies: text: ACK, das wäre die andere Alternative zur Korrektur gewesen. Ändert aber nix an der Tatsache, dass das Beispiel ursprünglich falsch dastand. --Kasper4711 15:38, 20. Mär 2006 (CET)
replies: text: Kleine Korrektur, index=0; nachfolger = 2* index +1; nachfolger2=nachfolger+1; Was das alte Beispiel betrifft, kann ich mich nicht dazu äussern, das aktuelle funktioniert. Doch ist es aufgrund der tatsache, dass in allen mir bekannten Sprachen die Arrays mit Index=0 beginnen, dieses Beispiel unbrauchbar. Ich werde demnächst mal ein C++ Beispiel posten, eventuell hilft das ja weiter ;) - Ntr0pY (nicht signierter Beitrag von 88.73.31.54 (Diskussion | Beiträge) 20:00, 20. Mär. 2006 (CET)
replies: text: Naja, unbrauchbar ist deswegen das Beispiel nicht. Alles eine Frage der Dimensionierung des Arrays, deswegen der Hinweis auf den verschenkten Bucket mit Index=0. --Kasper4711 11:04, 21. Mär 2006 (CET)
thread_title:  array-beginn bei 1 oder 0 

message: === aufwand ===
Ist der Aufwand, um den Heap am Anfang aufzubauen nicht nur O(n)? Die Wiederherstellung der Heap-Eigenschaft hat eine Komplexität von O(logn). (nicht signierter Beitrag von 137.226.101.1 (Diskussion | Beiträge) 12:59, 6. Aug. 2005 (CEST)
replies: text: Der Autor hat hier 2 unterschiedliche Worst Case Werte. Einmal O(n*log(n)) (richtig) und O(log(n))(falsch). Ich berichtige das.(mfg Ntr0py) (nicht signierter Beitrag von 193.138.91.175 (Diskussion | Beiträge) 11:00, 3. Mär. 2006 (CET)

text: Ja, da bin ich auch der Meinung. Ich ändere das mal... JaK 22:22, 19. Mär. 2007 (CET)

text: Wie kommt es denn, dass da immernoch O(n · log(n)) steht? Jemand, der sich sicher ist, bitte mal kommentieren oder berichtigen, danke! -- 91.65.229.43 12:23, 5. Dez. 2010 (CET)

text: kann jemand das mit 16000 untermauern? 16000 klingt ein bisschen wenig! (nicht signierter Beitrag von 88.70.9.33 (Diskussion | Beiträge) 14:47, 24. Jul. 2006 (CEST)
thread_title:  aufwand/laufzeit/komplexitaet 

message: Ist der Aufwand, um den Heap am Anfang aufzubauen nicht nur O(n)? Die Wiederherstellung der Heap-Eigenschaft hat eine Komplexität von O(logn). (nicht signierter Beitrag von 137.226.101.1 (Diskussion | Beiträge) 12:59, 6. Aug. 2005 (CEST)
replies: text: Der Autor hat hier 2 unterschiedliche Worst Case Werte. Einmal O(n*log(n)) (richtig) und O(log(n))(falsch). Ich berichtige das.(mfg Ntr0py) (nicht signierter Beitrag von 193.138.91.175 (Diskussion | Beiträge) 11:00, 3. Mär. 2006 (CET)
thread_title:  aufwand 

message: Hallo , mal was zur Laufzeit: "Das Versickern eines Elements von der Wurzel benötigt im ungünstigsten Fall (Worst Case) O(n · log(n)) Schritte." Müssten dass nicht O(log(n)) Schritte sein? Bei einem Aufwand von O(n) zur Erstellung des Heaps frag ich mich wie mann sonst auf O(n log(n)) als Gesamtaufwand kommt... (nicht signierter Beitrag von 84.61.208.162 (Diskussion | Beiträge) 09:54, 10. Apr. 2006 (CEST)
replies: text: Ja, da bin ich auch der Meinung. Ich ändere das mal... JaK 22:22, 19. Mär. 2007 (CET)

text: Wie kommt es denn, dass da immernoch O(n · log(n)) steht? Jemand, der sich sicher ist, bitte mal kommentieren oder berichtigen, danke! -- 91.65.229.43 12:23, 5. Dez. 2010 (CET)
thread_title:  laufzeit I 

message: Im Artikel steht
 Für genügend große n (> 16000) ist ein Heapsort im Durchschnitt schneller
 als ein optimierter Quicksort. Hinzu kommt das bessere Worst Case-Verhalten
 von O(n · log(n)) gegenüber O(n²) beim Quicksort, so dass bei großen 
 Sortiermengen Heapsort zu bevorzugen ist.
Das ist sehr zweifelhaft. Vielleicht ist O() von HSort besser, aber bei der Implementation auf dem Computer muss man beachten, daß nicht jeder Zugruff gleich lange dauert, die O()-Notation also nur von begrenztem Wert ist. Ein HSort springt im Gegensatz zu QSort viel mehr im Speicher wahllos hin-und her, verursacht also eine viel größere Menge an Cache-misses. Dadurch ist HSort dann oft doch langsamer als QSort. Daher gibt es viele Fälle, wo dann doch QSort die bessere Wahl ist. 
Dazu kommt, daß O(n^2) von QSort keine Bedeutung besitzt. Es ist zwar richtig, aber man kann zeigen, daß dieser Fall bei einem (sinnvollerweise) randomisierten QSort-Algorithmus beliebig unwahrscheinlich wird und für die Praxis nicht relevant ist. (nicht signierter Beitrag von John.constantine (Diskussion | Beiträge) 14:10, 5. Mai 2006 (CEST)
replies: text: kann jemand das mit 16000 untermauern? 16000 klingt ein bisschen wenig! (nicht signierter Beitrag von 88.70.9.33 (Diskussion | Beiträge) 14:47, 24. Jul. 2006 (CEST)
thread_title:  Laufzeit II 

message: Also ich finde es wesentlich verständlicher, wenn als Laufzeit "O(n + n log(n)) = O(n log(n))" angegeben wird.
Denn der initiale Aufbau des Heaps kostet O(n). Danach muss für jedes Element (Wurzel), das man aus dem Heap entfernt Heapify (Wiederherstellung der Heap-Eigenschaft) O(log(n)) aufgerufen werden. Daher kommt O(n log(n)). Das hat ja im Prinzip nichts mehr mit der Laufzeit für den Aufbau des Heaps zu tun. Die fällt nicht mehr ins Gewicht. --88.72.236.68 00:20, 23. Jul. 2007 (CEST)
thread_title:  laufzeit/verstaendlichkeit 

message: In diesem Artikel wird immer wieder etwas in der Komplexitätsbetrachtung falsch gemacht. Ich habe die Laufzeiten korrigiert. Insgesamt wirkt dieser Artikel als ob der Text nicht wirklich zu den theoretischen Grundlagen passt. (nicht signierter Beitrag von 84.63.0.237 (Diskussion | Beiträge) 22:30, 3. Mai 2006 (CEST)
thread_title:  Heapsort und Komplexität 

message: ich finde den artikel recht lesbar, allerdings ist für mich die verwendung von buchstaben statt zahlen als zu sortierende elemente weniger intuitiv... falls es nicht nur mir so geht sollte das geändert werden -- wizzar 07:37, 19. Dez 2005 (CET)
replies: text: Habe prinzipiell nichts dagegen einzuwenden, allerdings fällt dann evtl. die Unterscheidung zu den Indices schwieriger („Nummer 3 auf Position 5“ etc.). --Kasper4711 08:39, 19. Dez 2005 (CET)
replies: text: Finde die Buchstaben ok. Ist sicher etwas weniger intuitiv als Zahlen, aber da Heapsort eh nicht auf einen Blick verstanden wird macht das nix :) -NtropY (nicht signierter Beitrag von 88.73.31.54 (Diskussion | Beiträge) 20:00, 20. Mär. 2006 (CET)
thread_title:  zu sortierende symbole 

message: S P R E H O A|T     Wir versickern E nicht weiter, denn S ist bereits an der
^           ^       richtigen Position. Stattdessen vertauschen wir S und A.
Ich glaube es sollte eher "...,den T ist bereits an der richtigen Position" heißen, weil das der Grund ist, wieso E nicht weiter versickern kann.
Ich ändere das ganze einfach mal... (nicht signierter Beitrag von 84.165.9.12 (Diskussion | Beiträge) 18:23, 17. Feb. 2006 (CET)
thread_title:  kleiner fehler in beispiel 

message: Hallo, ich habe in dem Beispiel den Begriff "heap" in den Begriff "max-heap" geändert, da das präziser ist. ich hoffe ich hatte recht. noch schöner fände ich es, wenn das beispiel sich an einem min-heap orientieren würde, ich kann nämlich besser vorwärts buchstabieren als rückwärts :)
und noch was zum beispiel des heap-sortierens: da steht immer "x mit y vertauschen"... das klingt so, als wenn der "größere" buchstabe noch für den heap relevant wäre, aber das ist es ja nicht mehr, er kann ja bereits rausgenommen werden. 
danke, --Abdull 22:48, 4. Mär 2006 (CET)
thread_title:  heap -> max-heap 

message: ::Ich möchte noch hinzufügen, dass Heapsort eher zu den langsamen Sortierverfahren zählt. In einem anderen Video hat man 24 Sortierverfahren gegeneinander antreten lassen, um ein zufällig gemischtes Array zu sortieren. Heapsort erreichte dabei nur Platz 16.
::Platz 1: Radixsort (LSD) (12 Sekunden)
::Platz 2: Radixsort (MSD) (16 Sekunden)
::Platz 3: Quicksort (dual pivot) (17 Sekunden)
::Platz 4: Quicksort (ternary, L R ptrs) (18 Sekunden)
::Platz 5: Quicksort (L R ptrs) (21 Sekunden)
::Platz 6: Quicksort (L L ptrs) (22 Sekunden)
::Platz 7: Quicksort (ternary, L L ptrs) (23 Sekunden)
::Platz 8: Tim Sort (25 Sekunden)
::Platz 9: Shell Sort (26 Sekunden)
::Platz 10: std::sort (gcc) (26 Sekunden)
::Platz 11: Merge Sort (27 Sekunden)
::Platz 15: Smooth Sort (37 Sekunden)
::Platz 13: Block Merge Sort (WikiSort) (38 Sekunden)
::Platz 14: Comb Sort (39 Sekunden)
::Platz 15: Bitonic Sort (42 Sekunden)
::Platz 16: Heapsort (43 Sekunden)
::Platz 17: Binary Insertion Sort (51 Sekunden)
::Platz 18: Insertion Sort (60 Sekunden)
::Platz 19: Selection Sort (79 Sekunden)
::Platz 20: Coktail Shacker Sort (83 Sekunden)
::Platz 21: Gnome Sort (103 Sekunden)
::Platz 22: Cycle Sort (112 Sekunden)
::Platz 23: Bubble Sort (119 Sekunden)
::Platz 24: Odd-Even Sort (122 Sekunden)
::--Zahlenzauber (Diskussion) 15:55, 29. Dez. 2023 (CET)
thread_title:  Heapsort im Vergleich mit 23 anderen Sortierverfahren 

message: So ein Käse, Quicksort hat worstcase n²! --84.150.200.185 12:18, 16. Jul. 2008 (CEST)
replies: text: Nein, kein Käse. Quicksort ist im Worst-Case 70% schneller als Heapsort. --Zahlenzauber (Diskussion) 15:06, 29. Dez. 2023 (CET)
thread_title:  quicksort worstcase 

message: Kann es sein, das "Prinzip der Sortierung" und das "Beispiel mit Zahlen" nicht übereinstimmen. Sollte man vielleicht dazuschreiben. Da das Beispiel mit Zahlen ja absteigend sortiert, vorher aber von aufsteigend die Rede ist. Der Artikel an sich ist aber richtig gut zu verstehen. Gefällt mir. (nicht signierter Beitrag von 85.179.137.76 (Diskussion | Beiträge) 13:56, 18. Sep. 2007 (CEST)
thread_title:  prinzip der sortierung inkonsistent mit beispiel 

message: "Man beachte, dass für die zweite Hälfte jedes Arrays die Heap-Eigenschaft bereits erfüllt ist, denn jeder Knoten in der zweiten Hälfte des Arrays entspricht im Heap einem Blatt, hat also keinen Nachfolgeknoten, dessen Wert größer sein könnte als der eigene (im Folgenden wird der Einfachheit halber der Knoten mit dem größten Wert der „größte Knoten“ genannt)."
Das ist doch schon wieder Käse! Das kann man so nun wirklich nicht sagen, denn immerhin haben die Knoten aus der hinteren Hälfte Vorgängerknoten, und die Knoten müssen auch mit diesen Knoten in der Heapbedingung: Kinder>Eltern, genügen.
Habe ich zB das Array: 4,3,2,1 dann gilt doch für 2 und 1 nicht die (Min-)Heapbedingung, weil sie kleiner sind als ihre Eltern!
Denn der MinHeap zu dem Array lautet: 1, 2, 3, 4. Und wo ist jetzt die zweite Hälfte gleich?
Ich weiß nicht, der Satz ist nicht mal einfach nur schlecht formuliert oder so, sondern macht einfach keinen Sinn, ich wäre dafür ihn ersatzlos zu streichen.
IMHO kann man einen Heap nur so machen, indem man aus einem unsortierten Array kontinuierlich extractMin ausführt. BZW eben einen Sortieralgorithmus laufen lässt und dann einfach den Heap konstruiert.
--84.150.200.185 12:23, 16. Jul. 2008 (CEST)
thread_title:  Array zum Heap machen 

message: Im Beispielbild "Heapsort.png" ist meiner Meinung nach ein kleiner Fehler. Direkt nach der Bildung des Heaps sind die Kinder von 18 falschherum. Wenn man von hinten einliest ergibt sich die 8 als rechtes Kind, hier ist es leider das linke. (nicht signierter Beitrag von 78.34.131.42 (Diskussion | Beiträge) 19:57, 4. Aug. 2008 (CEST)
replies: text: Ich muss hier zustimmen, die Kinder der "18" sind beide falsch herum. Die "6" muss sich links und die "8" rechts befinden. --Zahlenzauber (Diskussion) 05:35, 29. Dez. 2023 (CET)
replies: text: Ich habe die Fehler mit der "6" und "8", sowie einem Tausch-Pfeil, der zu viel platziert wurde, zwar beheben können, allerdings kann ich die "reparierte Grafik" nicht hochladen, weil ich feststellen musste, dass es sich beim Original um das Werk eines anderen Nutzers handelt (Urheberrecht). Ich habe den betreffenden Nutzer angeschrieben und ihm angeboten, ihm die reparierte Grafik zur Prüfung per E-Mail zuzusenden. Warten wir die Antwort ab. Wenn er die Grafik übernimmt, dann werden sich die Fehler von alleine beheben. --Zahlenzauber (Diskussion) 17:19, 29. Dez. 2023 (CET)
replies: text: Wir reden über , oder? Das kannst du problemlos überschreiben oder als neues Bild hochladen, solange du es unter einer kompatiblen Lizenz veröffentlichst und den Urheber nennst. --Dexxor (Diskussion) 17:01, 30. Dez. 2023 (CET)

text: Ja, genau um dieses Bild geht es. Muss ich es nur unter dem gleichen Namen hochladen, oder wie würde das gehen? Ein Problem besteht noch darin, dass ich mit meinem Programm unter PNG keine transparenten Farben erzeugen kann, wie beim Original. --Zahlenzauber (Diskussion) 01:45, 31. Dez. 2023 (CET)
replies: text: Wenn du nach unten scrollst, findest du den Link Eine neue Version dieser Datei hochladen. Dort solltest du aber kein PNG, sondern ein SVG hochladen. SVG hat den Vorteil, dass man es mit Inkscape leicht bearbeiten kann. --Dexxor (Diskussion) 09:53, 31. Dez. 2023 (CET)
replies: text: Tut mir leid, ich habe leider nur "Paint" auf meinem Computer. --Zahlenzauber (Diskussion) 14:33, 31. Dez. 2023 (CET)
replies: text: Aber ich könnte auch mit Excel eine neue Grafik erstellen, bei der alle Schritte in einer Tabelle angeordnet sind. Das dürfte dann wohl auch besser verständlich sein. Dafür würde ich dann auch andere Zahlen verwenden. --Zahlenzauber (Diskussion) 14:37, 31. Dez. 2023 (CET)
thread_title:  beispielbild fehlerhaft 

message: Ich finde den Artikel sehr missverständlich.
Es klingt so als wäre es die Hauptfunktion des Heap-Sorts einen Max-Heap zu erstellen.
Die eigentliche Funktion des Algorithmus, nämlich eine aufsteigende Sortierung wird überhaupt nicht erwähnt.
Stattdessen wird in den Beispielen davon ausgegangen, dass diese Aufgabenstellung klar ist.
Ich denke in einem Artikel über einen Algorithmus, sollte vor allem stehen, was dieser Algorithmus tut und nicht nur was sein Teilalgorithmus macht.
Man könnte z.B. den Text unter der Animation in den eigentlichen Text einfügen - ohne diesen hätte ich überhaupt nicht verstanden, wie der HeapSort funktioniert. (nicht signierter Beitrag von Tyru (Diskussion | Beiträge) 01:18, 24. Feb. 2010 (CET)
thread_title:  Sortieren vs. Erstellen des Max-Heap 

message: Hallo euch Artikelautoren. Großes Lob an euch für den gesamten Artikel. Man erkennt, dass ihr versucht, einen Spezialbegriff auch einem Laien verständlich zu erklären. Beispiele eignen sich dafür sehr gut! Ich bin Fast-Laie. Leider kann ich den Anfang vom 2. Schritt in diesem Beispiel „Wir fahren mit dem A fort.“ nicht nachvollziehen. Wieso fahren wir gerade mit „A“ fort? Komm ich leider nicht mit. Wenn ihr denkt, dass das auch anderen so gehen könnte, dann ergänzt doch bitte eine kurze Begründung, warum man beim 2. Schritt A wählt. Beste Grüße --W like wiki 20:15, 21. Jun. 2010 (CEST)
replies: text: Wer das Wort Array kennt, müsste auch wissen, was dort ein Index ist. Ein passender Wikilink zu Index (Mathematik) wäre aber trotzdem möglich. Aber dass du die Notation 2·i nicht verstehst, kaufe ich dir nicht ab. Der ganze Sachverhalt könnte allerdings besser erklärt werden, vielleicht aber ausführlicher an einer zentralen Stelle, zum Beispiel im Artikel Repräsentation von Graphen im Computer in einem neuen Abschnitt über Bäume. --Zahnradzacken 14:17, 22. Jun. 2010 (CEST)
replies: text: Hallo Zahnradzacken, hmmm...Multiplikation. Lustig, manchmal erkennt man das naheliegendste nicht. War davor wahrscheinlich auf zuviel anderen Mathematik-Artikeln gewesen, die dann immer schnell in mir exotisch erscheinende spezielle Notationen übergehen. Habe werde die Links mal in die Seite so einbauen. PS.: Es bleibt noch die Frage, wie würde die Überführung in ein Max-Heap vorsichgehen, wenn es ein 9-buchstabiges Wort wäre HEAPSORTO zB :)? Dann hätte könnte man im ersten Schritt das S mit keinem Nachfolger vergleichen. Vergleicht man es dann mit seinem Vorgänger oder geht man gleich zum nächsten Knoten P? --W like wiki 00:58, 23. Jun. 2010 (CEST)
thread_title:  Abschnitt: Beispiel für die Überführung in einen Max-Heap 

message: Ich habe mit Excel eine - wie ich finde - verbesserte grafische Darstellung der Funktionsweise von Heapsort erstellt. Daher würde ich gerne mal nachfragen, ob Ihr ebenfalls der Meinung seid, dass man das aktuelle Beispielbild im Artikel durch meines Ersetzen und den Text entsprechend anpassen sollte? Wenn ich an den Texten in der Grafik etwas ändern soll, dann kann ich das natürlich sehr schnell machen.
 --Zahlenzauber (Diskussion) 14:17, 24. Mär. 2024 (CET)
thread_title:  Besseres Beispielbild