Arrays sortieren

[Chippie82]

Hallo Leute, ich bin eingefleischter Delphianfänger , meine damit muss versuchen mir alles selbst beizubringen, große Hilfe ist unser Lehrer nicht und hat auch keine lust etwas anständig zu erklären. Nun zu meinem Problem: Das Programm was ihr unten seht ist soweit lauffähig, jetzt möchte ich nur noch meine Messwerte die ich eingebe in meinem Memofeld sortiert angezeigt bekommen. Habe aber keine Idee wie das Funktionieren soll, auch nach stundenlanger Suche im Internet. Ich hoffe ihr könnt mir da weiterhelfen?

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls;

type
  TForm1 = class(TForm)
    Messwerte: TMemo;
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button3Click(Sender: TObject);
    procedure MesswerteChange(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  Messwert: double;
  Summe:double;
  Anzahl:Integer;
  Mittelwert: Double;
  Haelfte:Double;

implementation


{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);
var

  code:integer;
begin
   Summe:= 0;
   Anzahl:= 0;
  repeat
  Anzahl:= Anzahl + 1;
  Summe:=Summe+Messwert;
  val (InputBox('MESSWERT','bitte Messwert eingeben', ''),Messwert,code);
  If Messwert >0 then
  Messwerte.lines.add('Nr.'+inttostr(Anzahl)+':'+floattostr(Messwert));


  UNTIL Messwert = 0;
end;


procedure TForm1.Button2Click(Sender: TObject);
begin


Mittelwert:= Summe / (Anzahl-1);
Haelfte := Summe / 2;
Messwerte.lines.add('Die Summe ist '+floattostr(Summe));
Messwerte.lines.add('Der Mittelwert ist die Summe geteilt durch die Anzahl der Eingaben '+floattostr(Summe)+':' +floattostr(Anzahl-1)+'=' +floattostr(Mittelwert));
Messwerte.lines.add('Die Hälfte der Summe ist '+floattostr(Haelfte));
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
close;
end;

procedure TForm1.MesswerteChange(Sender: TObject);
begin

end;

end.

[edit=alcaeus]Delphi-Tags eingefuegt. In Zukunft bitte selbst machen Mfg, alcaeus[/edit]

[RavenIV]

füg bitte erst mal delphi-tags ein, dann kann man den Code besser lesen...

[TeronG]

Sortieren ähh und wie?
Die Messwerte werden doch eh der Reihe nach hinzugefügt
und per knopfdruck werden dann noch Summe & Co dazugeschrieben ...
oder willst du sie von GROSS nach KLEIN sortieren ??


Ach ja: WELLCOME 2 the DP

[marabu]

Hallo Chippie,

herzlich willkommen in der Delphi-PRAXiS.

Vielleicht kannst du ja deinen Quelltext noch in die Delphi-Code tags einwickeln - sonst tun einem die Augen so weh.

Wenn du die Werte in einer Schleife entgegen nimmst, dann kannst du die Sortierung über einen insertion sort realisieren - jeder andere Sortier-Algorithmus ist aber auch okay. Ich würde mir eine Klasse zur Verwaltung der Messwerte schaffen:

Delphi-Quellcode:

unit DblList;

interface

type
  TDoubleList = class
  private
    FValues: array of double;
    FSum: double;
    function GetValue(index: integer): double;
  public
    procedure Add(value: double);
    function Count: cardinal;
    procedure Empty;
    property Sum: double read FSum;
    property Value[index: integer]: double read GetValue;
  end;

implementation

procedure TDoubleList.Add(value: double);
var
  i: integer;
begin
  SetLength(FValues, Succ(Length(FValues)));
  i := High(FValues);
  repeat
    Dec(i);
    if (i < 0) or (FValues[i] <= value) then
    begin
      FValues[Succ(i)] := value;
      Break;
    end else FValues[Succ(i)] := FValues[i];
  until false;
  FSum := FSum + value;
end;

// hier fehlt noch ein wenig
// aber das schaffst du bestimmt alleine

Das Einlesen der Messwerte könnte dann so aussehen:

Delphi-Quellcode:

uses
  QDialogs;

procedure TMainForm.InputButtonClick(Sender: TObject);
var
  dValue: double;
begin
  dValue := 0;
  repeat
    if not InputQuery('Messwert eingeben', 'Wert', dValue)
    or (dValue = 0) then
      Break;
    DoubleList.Add(dValue);
  until false;
end;

Grüße vom marabu

[Chippie82]

Hallo, Danke erst mal an den der meinen Quellcode umgeändert hat.
Wie geht das überhaupt genau?
Mit dem Sortieren ist das so gemeint, dass ich vorhabe meine eingetragenen Messwerte mit der kleinsten eingegebenen Zahl im Memofeld anzeigen lassen möchte und nicht der Reihe nach, wie ich sie in der Inputbox eingegeben habe.

Unser Lehrer hatte uns folgendes vorgegeben, damit sollte man es lösen können, aber ich habe Stunden davor gesessen und es nicht hin bekommen.

Hier sind die vorgaben:
var Messwert: array [1..10] of double // Hiermit werden 10 Einträge zugeordnet ist mir verständlich, wenn ich dieses in meinem Quelltext eingebe, bekomme ich eine Fehlermeldung bei: Summe:=Summe+Messwert; eine Fehlermeldung. Als Zuordnung:

Delphi-Quellcode:

Messwert[i] := x;
x := Messwert[i];

Es sollte dann linear sortiert werden
mit den variablen i,j

Im Struktogramm war angegeben:

Code:

Für i = bis Anzahl -1
Für j= i + 1 bis Anzahl
Wert: [i] > Wert j
wenn true dann:
tausche Wert [i] mit Wert [j]

wenn false dann zum Programm

Könnt ihr mir das genauer erläutern???

Und wie geht das mit dem Quelltext?
Sieht anders viel besser aus.


Vielen Dank für eure Bemühungen.



Euer Chippie82


PS. Hoffe das ich das irgendwann mal alles verstehe, damit ich anderen auch helfen kann.

[edit=Sharky]Um es etwas besser lesen zu können habe ich einige Code-Tags eingefügt. Mfg, Sharky[/edit]

[marabu]

Hallo,

schau dir einen Beitrag mal mit der Zitat-Funktion an, dann erkennst du die tags, die den Quelltext besser lesbar machen. Über dem Beitragseditor befindet sich eine Werkzeugleiste. Experimentiere einfach mal mit den einzelnen Schaltern, indem du Text in deinem Beitrag markierst und dann einen Schalter klickst. In der Vorschau kannst du dann die Effekte sehen - ohne gleich alle an deinen Experimenten teilhaben zu lassen.

Die dir gestellte Aufgabe ist die Implementierung eines Bubble Sort Algorithmus. Dabei geht man durch das Array und vergleicht paarweise. Bei fehlerhafter Sortierung tauschen die beiden Werte ihren Platz und weiter geht es. Wenn du dir dein Array senkrecht aufmalst und das Element mit dem größten Index oben ist, dann steigen beim Sortieren die großen Werte alle nach oben - wie Luftblasen im Wasserglas (die Metapher ist nicht immer ganz schlüssig). Deshalb Bubble Sort.

Bei einem Durchgang steigt nur ein Element auf, deshalb musst du mehrmals durch das Array gehen. Und wenn du das erste Element bis zu seinem neuen Platz getauscht hast, dann steht der kleinste Wert an dessen alter Stelle und du kannst diese Stelle beim zweiten Durchgang ausklammern. Deshalb die zwei verschachtelten Schleifen.

Die Umsetzung nach Delphi sollte keine großen Probleme bereiten. Da es aber einige Details gibt, die sich dir erst nach einer gewissen Zeit erschließen, hänge ich dir ein wenig Code an. Versuche es aber erstmal selbst.

Wenn du weitere Hilfe brauchst, dann kannst du mit dem Stichwort Sortieren hier im Forum suchen. Auch Wikipedia hat sicher etwas für dein Lesestudium zu bieten.

Grüße vom marabu

[Der_Unwissende]

Hi,
also erstmal vorweg, wenn du eine Nachricht schreibst, dann hast du über diesem Edit-Feld in das du den Text tippst noch ein paar Button (B, i, U, Zitat, Delphi-Code,...) und nun ja, Delphi-Code leitet einen Delphi-Code Teil ein. Wenn du deinen Quelltext eingefügt hast, dann beendest du den mit dem selben Knopf (hat dann ein * vor).
Ansonsten noch als Tip, schau dir die Einrückungen an, die gemacht wurden sind. Das macht Code immer sehr viel leichter lesbar und damit auch immer besser verständlich. Wirst du sicher auch schnell merken, ansonsten findest du sicher auch hier viel zum Thema guten Programmierstil (nicht als Kritik verstehen!, nur du stehst offensichtlich noch am Anfang und das ist der perfekte Zeitpunkt sich mit Programmierstil zu beschäftigen. Hab da Sachen von Leuten die für schlappe 40€/Std arbeiten gesehen, egal)

Ja, zu

Zitat:

Im Struktogramm war angegeben:

Quellcode: markieren
Für i = bis Anzahl -1
Für j= i + 1 bis Anzahl
Wert: [i] > Wert j
wenn true dann:
tausche Wert [i] mit Wert [j]

wenn false dann zum Programm

Das ist ein sehr einfacher Bubblesort. Da findest du auch schon ne Menge im Netz zu. Die einfache Idee hinter diesem Algorithmus ist auch der Namensgeber. Stell dir einfach mal vor, deine Werte die du sortieren möchtest sind in Blasen, dein Array ist eine Flüssigkeit. Dann sortierst du so, dass die leichtesten Blasen schnell aufsteigen, die ganz schweren unten bleiben (ok, kann man sicher schöner erklären).

Konkret im Struktogramm/Programm machst du dazu nichts anderes als paarweise zu sortieren. Der Einfachheit halber erklär ich es dir mal an einem Array mit 4 Elementen (Werte : Array[0..3] of Integer). Legen wir noch fest, dass aufsteigend sortiert wird.
Dann vergleichst du jetzt Werte[0] mit Werte[1], wenn Werte[0] > Werte[1], dann tauscht du die beiden. Wenn nicht, machst du einfach nichts. Dann guckst du dir Werte[1] und Werte[2] an und machst das gleiche, dann Werte[2] und Werte[3], dann bist du jetzt alle 4 Werte durchgegangen.
Was jetzt sicher ist, ist dass die leichtest Blase / die größte Zahl aus Werte ganz rechts (also richtig) steht. Das ist die innere Schleife (das mit dem j). Jetzt bleiben aber noch die anderen Werte, also zweitgrößte bis kleinste. Hier musst du also wieder das gleiche tun, also ganz rechts anfangen und immer wieder tauschen. Für dieses innere Tauschen brauchst du immer so viele Schritte wie du Elemente im Array hast (ok, - 1) um alle Paare verglichen zu haben. Für die äussere wäre jetzt die Überlegung, wie oft musst du maximal tauschen, wenn du die schlechteste vorsortierung hast? Für diese Art des Sortierens ist der Worst-Case eindeutig ein falschrum sortiertes Array (schau dir das mal auf Papier an, mit den Array[4,3,2,1] oder so). Hier müsstest du also auch 3 mal (länge Array - 1) die äussere Schleife durchlaufen.

Es gibt dabei noch ein paar Dinge, die man optimieren kann. Wie gesagt beim ersten aufsteigenden Sortieren ist schon mal der größte Wert ganz links. Das heißt für's nächste Sortieren brauchst du den letzten Wert nicht mehr anschauen, der ist schon richtig sortiert! Nach dem zweiten Durchlauf, sind die letzten beiden sortiert...
Dass heißt, abhängig von dem äusseren i kannst du dein inneres j beschränken, da der hintere Teil beim aufsteigenden Sortieren schon richtig ist.
Jetzt kann es noch sein, dass du nicht den Worst-Case hast und du nicht (Länge des Arrays - 1) mal tauschen musst. Dann bist du jetzt schon nach n-Schritten fertig. Doch woher weißt du dass? Ganz einfach, wenn alles sortiert ist, dann brauchst du gar nichts tauschen. Also merkst du dir ob du in der innere Schleife getauscht hast oder nicht. In der äusseren guckst du nun ob getauscht wurde, wenn nicht, dann bist du schon fertig mit dem sortieren und brichst das weitere Sortieren ab. Sonst machst du ganz einfach
weiter!

Hoffe auch das ich das Struktogramm soweit richtig verstanden habe, denn es fehlt der Wert bei dem i startet. Zudem musst du bei Arrays immer aufpassen, wie der Index läuft. Wenn die bei 0 anfangen, dann laufen die auch nur bis Index (Anzahl - 1), wenn die bei 1 anfangen dann natürlich bis Anzahl. Schau dir da am besten mal High(<Array>) und Low(<Array>) an


Ok, jetzt noch eine Kleinigkeiten, einerseits hoffe ich du verstehst schon mal grob wie das alles funktioniert. Was Code posten angeht, halte ich mich mal zurück, versuch einfach mal was und poste es, hier wird dir dann geholfen. Und auch wenn du alles fertig bekommst (also im Netz), ist nicht das selbe! Man fühlt sich einfach gut wenn man Probleme löst (und mit solchen haben hier sicher die meisten mal angefangen).

[shmia]

In meinem Artikel Basisklasse für Sortieralgorithmen
wird gezeigt, wie man ALLES sortieren kann, was sich irgendwie wie ein Array ansprechen lässt.
Quicksort, Insertion sort, Selection sort und Bubble sort sind vorhanden.

Das könnte aber deinen Lehrer überfordern.

[Chippie82]

Also verstehe ich das richtig, zuerst muss ich meine Messwerte zu arrays machen mit:

var Messwert : array[1..4] of Integer; Somit habe ich dann die Möglichkeit jeden eingegebenen Messwert mit: Messwert[1], Messwert[2] usw. anzusprechen. Und diese muss ich dann vergleichen. Also nehme ich gar nicht i und j sondern Messwert[1], Messwert[2] usw. und vergleiche die alle oder?



Das sieh dann so in etwa aus?

Zitat:

Messwert: [1] > Messwert [2]
wenn true dann:
tausche Messwert [1] mit Messwert [2]
wenn false dann weiter

Messwert: [1] > Messwert [3]
wenn true dann:
tausche Messwert [1] mit Messwert [3]
wenn false dann weiter

Messwert: [1] > Messwert [4]
wenn true dann:
tausche Messwert [1] mit Messwert [4]
wenn false dann weiter

Dann müßte ich noch 2 mit 3, 2 mit 4 und 3 mit 4 vergleichen oder?

Euer Chippie82

[marabu]

Das mit dem array hast du richtig erkannt. Das array vereinfacht vieles:

Delphi-Quellcode:

var
  Messwert: double;

  Messwert1: double;
  Messwert2: double;
  Messwert3: double;

  Messwerte: array [1..3] of double;
  i: integer;

Du kannst dann eine Variable anstatt über ihren Namen über ihre Hausnummer ansprechen:

Delphi-Quellcode:

Messwert1 := Messwerte[1];
Messwerte[3] := Messwert3;

Nur durch den Zugriff über diese Hausnummer (Index) ist es überhaupt möglich einen Algorithmus elegant und universell zu formulieren:

Delphi-Quellcode:

procedure BubbleSort(var MessWerte: array of double);
var
  i, j: integer;
  messWert: double;
begin
  // vom ersten bis zum vorletzten Eintrag
  for i := Low(MessWerte) to Pred(High(MessWerte)) do
    // vom nächsten bis zum letzten Eintrag
    for j := Succ(i) to High(MessWerte) do
      // Ordnung prüfen
      if MessWerte[i] > MessWerte[j] then
      begin
        // vertauschen
        messWert := MessWerte[i];
        MessWerte[i] := MessWerte[j];
        MessWerte[j] := messWert;
      end;
end;

Der direkte Vergleich von einzelnen Variablen ist weder elegant, noch unabhängig von der Anzahl der items.

marabu