an die crakcheads des programmieren

ich soll proggi schreiben 3 zahlen eingeben (will es mit felder machen) un das soll nach größe sortiert werden..
kann mir jemand anwendungsbeispiel geben?

hab gegoogelt aber das ist doch sehr beschossen dargeswtellt wuerd das gern in nem einfachen proggi sehen

Ui,ui Bubblesort, vor 2 Jahren in Java programmiert... frag mich net mehr, wie das funzt
Evlt hab ich den Quellcode noch hier iwo rumfliegen, aber wozu man diese umständliche Art des Sortierens anwedet, ist mir nicht bekannt :lol2:

:tschau:

Hi Detective und schön, dass du sowas machen darfst.
Also

[Zur Link-Ansicht bitte registrieren.]

ist eine Sortier-Methode, die wie folgt funktioniert:
Du hast z.B. eine Zahlenkette von 5 Zahlen, auch

[Zur Link-Ansicht bitte registrieren.]

genannt.
Hier ein Beispiel: { [8] [76] [66] [4] [88] }
Jetzt werden nacheinenader immer zwei Zahlen verglichen, und falls die erste größer als die zweite ist, werden die Zahlen getauscht, das sieht dann so aus:
Als erstes werden die 8 und die 76 überprüft. Da die größere Zahl an zweiter Stelle steht geschieht nichts. Nun zur nächsten Zahl.
76 und 66. Da die 76 größer als die 66 ist, werden beide Zahlen getauscht.
Dieses Prinzip wiederholt man solange, bis alle Zahlen in der Größenordnung richtig stehen. Vorne die kleinste, hinten die Größte, hier mal die komplette Sortierung der Zahlenkette:

[8] [76] [66] [4] [88]

[8] [76] [66] [4] [88]
[8] [76] [66] [4] [88] <-- tauschen
[8] [66] [76] [4] [88] <-- tauschen
[8] [66] [4] [76] [88]
[8] [66] [4] [76] [88]
[8] [66] [4] [76] [88] <-- tauschen
[8] [4] [66] [76] [88]
[8] [4] [66] [76] [88]
[8] [4] [66] [76] [88] <-- tauschen

[4] [8] [66] [76] [88]

Das ganze funktioniert natürlich auch mit drei Zahlen.

Jetzt gilt es den Code heraszufinden.
Grob könnte man es so zusammenfassen:
Du baust eine Wiederholung, die, solange eine Wahr/Falsch-Variable 'falsch' ist, immer wieder die nächsten Zwei zahlen überprüft und ggf. vertauscht.
Zusätzlich musst du bei jedem Durchgang überwachen, ob überhaupt eine Zahl vertauscht wurde. Denn am Schluss wird ja noch einmal durch jede Zahl durchgegangen, unendlich weiter. Wenn aber nichts mehr verändert wurde merkst du dass dann, setzt die Anfangs-Variable auf 'wahr', und die Schleife stoppt.
Das ist das Grundprinzip.

Code gibt es genug, wenn du mit Google danach suchst.
Ich habe diese hier z.B. durch Google gefunden:



[Zur Link-Ansicht bitte registrieren.]




[Zur Link-Ansicht bitte registrieren.]



Hier findest du Code-Snippets vor allem in VB-Net/C#, falls du das ganze nach C++ übersetzen kannst:


[Zur Link-Ansicht bitte registrieren.]

Naja das überprüfen ob eine größer oder kleiner ist ist hier denke ich das kleinste Problem. Schwieriger wirds, dass man eine Zahl immer zwischenspeichern muss beim vertauschen.
Wenn du mal nach Dreieckstausch googlest findet man was
Und das muss du halt in die Mittlere Schleife packen und darum eine Schleife die gröer kleiner vergleicht.
Kann sowas schwer erklären, musste das einem zeigen.

Naja grob ausgedrückt so:
Sorry hab jetzt einfach mal meine eigene Sprache verwendet, ich will ihm ja nicht einfach den C++-Code hinschmeißen und er kanns Drag+Drop ne.

Zahlenfolge = {Zahl1; Zahl2; Zahl3};
Getauscht = falsch; ## Dient der Übrprüfung ob noch ein Änderung vorgenommen wurde

WIEDERHOLE(solange [Getauscht == falsch]) ## Wenn keine Überprüfung mehr vorgenommen wurde wird die Schleife beendet
{
    (Ausgangsstellung:) Getauscht = falsch; ## Ausgangswert für neuen Durchgang zurücksetzen
    WIEDERHOLE(Anfangsindex [i = 0] | jede Schleife -->[i + 1] | bis [i = Zahlenfolge.AnzahlZeichen]) ## Festlegen eines Indexes der mit jedem Durchlauf um eins erhöht wird, sodass jede Zahl im Array nach der Reihe überprüft wird
    {
        WENN(Zahlenfolge[Index --> i] > Zahlenfolge[Index --> (i+1)]) ## Prüfen ob die erste größer als die zweite Zahl ist
        DANN
        {
            Variable x = Zahlenfolge[Index --> (i+1)]; ## Zahlen tauschen
            Zahlenfolge[Index --> (i+1)] = Zahlenfolge[Index --> i] ## Zahlen tauschen
            Zahlenfolge[Index --> i] = x; ## Zahlen tauschen

            Getauscht = wahr; ## Da getauscht wurde darf die Schleife noch nicht beendet werden --> Getauscht auf wahr setzen
        }
    }
}

Hab mein Wissen nochmal etwas aufgefrischt (Google, eigene Dateien)

also in Java ist es eigentlich nicht so kompliziert, ich weis nicht, wie sich das auf C++ / C# übertragen lässt, müsste aber ähnlich sein

/**
*Bubblesort
*einfacher Aufbau mit den Variablen a[] (Array), j, i und h
**/
public class BubbleSort 
{  
  
  public void BubbleSort(int a[]) 
  {
    int h;  //Hilfsvariable fürs Vertauschen
    for (int i=0; i < n-1; i++)          
      for (int j=n-1; j > i; j--)        
        if (a[j-1] > a[j])                 
         {
            h = a[j-1];                
            a[j-1] = a[j];                
            a[j] = h;                   
         }
  } 

}

:tschau: