aus einem Array die kleinste Zahl herausfinden

[gangs-taas]

hey,
ich wollte euch fragen, ob es einen befehl oder eine einfache möglichkeit gibt aus einem array die kleinste zahl zu ermitteln ?

danke schonmal :-D

[Teekeks]

mit schleife von vorne bis hinten durchgehen und die aktuell kleinste Zahl in eine Variable speichern (wenn du willst in eine weitere die entsprechende Indexnummer).

Gruß Teekeks

[Meflin]

Oder schneller :P : Array sortieren und erstes / letztes Element ausgeben.

[Aphton]

Zitat:

Zitat von Meflin

Oder schneller :P : Array sortieren und erstes / letztes Element ausgeben.

Warum soll das schneller sein?
Beim Sortieren wird höchstwahrscheinlich das Array mehr als nur 1x durchlaufen;
Beim Suchen der kleinsten Zahl aber nicht

MfG

[jfheins]

Zitat:

Zitat von Meflin

Oder schneller :P : Array sortieren und erstes / letztes Element ausgeben.

Schneller? Nö.

Sortieren braucht n*log(n)
Einmalige, lineare Suche O(n)

Falls man also nicht mehrmals das kleinste Element braucht, ist das Sortieren langsamer :P

Und da man einen konstanten Faktor vernachlässigen kann, ist das theoretisch sogar noch der Fall, wenn du 10 mal das kleinste Element suchst :P

[Wolfgang Mix]

Nimm die Variante von Teekeeks, am einfachsten mit 'ner FOR-Schleife.

Gruß

Wolfgang

[Dax]

Wobei 10 eine nicht weiter spezifizierte Konstante sei, die im Anwendungsfall auch den Wert 42 annehmen könnte *g*

[Wolfgang Mix]

Schau dir mal diesen Code aN, habe ich gerade mal gemacht:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var zahl : array[1..1000] of integer;
    i,min:integer;
begin
   randomize;
   for i:= 1 to 10 do
   begin
     zahl[i]:=random(1000)+1;
   end;
   min:=1000;
   for i:= 1 to 10 do
   begin
     if zahl[i] < min then min:=zahl[i];
   end;
   edit1.Text:=IntToStr(min);
end;

Gruß

Wolfgang

[DeddyH]

Man könnte aber auch MinIntValue aus der Unit math benutzen ;)

[Wolfgang Mix]

;-)

[gangs-taas]

danke
ich habs mit ner schleife gelöst :-D

[himitsu]

zum Thema sortuert = schneller

wenn das Array vorher schon sortiert ist, dann isses natürlich schneller :angel2:

[alzaimar]

Zitat:

Zitat von himitsu

wenn das Array vorher schon sortiert ist, dann isses natürlich schneller :angel2:

Woher weiss man das? :stupid:

[Meflin]

Zitat:

Zitat von alzaimar

Woher weiss man das? :stupid:

Indem man es beim Einfügen schon sortiert hält :mrgreen:

Aber genug der Theorie. Gesetz dem äußerst unwahrscheinlichen Fall, dass man tatsächlich nur ein allereinziges Mal das Minimum haben will, ist lineare Suche wirklich das Beste :stupid:

[alzaimar]

Zitat:

Zitat von Meflin

Zitat:

Zitat von alzaimar

Woher weiss man das? :stupid:

Indem man es beim Einfügen schon sortiert hält :mrgreen:

Das ist dann auch langsamer als mal eben in einem unsortierten Array zu suchen :)

Zitat:

Zitat von Meflin

Gesetz dem äußerst unwahrscheinlichen Fall, dass man tatsächlich nur ein allereinziges Mal das Minimum haben will

Wieso sollte ich öfter das Minimum eines Arrays ermitteln? Ändern tut es sich doch eh nicht :stupid:

Nun zur Theorie:
Wenn ich eine listenartige Datenstruktur inklusive Kenntnis des kleinsten/größten Elements benötige, werde ich meine Basisstruktur u.a. danach aussuchen, ob ich die Elemente sortiert benötige. Wenn nicht, und Löschoperationen selten sind, dürfte eine unsortierte Liste eine gute Wahl darstellen. Ansonsten empfehle ich eine Skiplist, die hier im Gegensatz zu einer sortierten Liste stets optimale Ergebnisse liefert. So sind so gut wie alle Operationen näherungsweise O(1), wohingegen eine sortierte Liste beim Einfügen und Löschen einen Aufwand O(n) und beim Suchen O(log n) aufweist. Nicht besonders, wenn Du mich fragst.

[Namenloser]

Zitat:

Zitat von Meflin

Zitat:

Zitat von alzaimar

Woher weiss man das? :stupid:

Indem man es beim Einfügen schon sortiert hält :mrgreen:

Kommt aber darauf an, wie man das macht. Wenn man quasi Insertion-Sort verwendet, ist es wahrscheinlich langsamer, weil die Elemente imemr wieder verschoben werden müssen. Und natürlich wird auch dabei das Array durchgescannt, mit dem Unterschied dass man hier eine binäre Suche verwenden kann, was aber nur bei größeren Mengen an Daten einen Geschwindigkeitsvorteil bringt.

[Meflin]

Zitat:

Zitat von NamenLozer

Wenn man quasi Insertion-Sort verwendet, ist es wahrscheinlich langsamer

Wieso auch nicht gleich BogoSort :stupid:

[himitsu]

Und wenn sich die Werte im Array ändern?

Dann gibt es für's Hinzufügen 2 Wege

- entweder sortiert hinzufügen
- oder beim Hinzufügen direkt mit den zwischengespeicherten Min- und Max-Werten vergleichen und diese so aktuell halten

[Wolfgang Mix]

Ergänzung zu Post 8:

Hier eine bessere Testvarinte:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
 var zahl : array[1..1000] of integer;
  i,min,merker:integer;
begin
  randomize;
   for i:= 1 to 1000 do
   begin
     zahl[i]:=random(10000)+1;
   end;
   min:=1000;
   for i:= 1 to 1000 do
   begin
     if zahl[i] < min then
     begin
       min:=zahl[i];
       merker:=i;
     end;
   end;
   edit1.Text:=IntToStr(min);
   edit2.Text:=IntToStr(merker);
end;

Gruß

Wolfgang

[alzaimar]

Zitat:

Zitat von Wolfgang Mix

Hier eine bessere Testvarinte:

Und hier eine kürzere Testvariante:

Delphi-Quellcode:

KleinsterWert := Math.MinIntValue(zahlArray);

[DeddyH]

Viel zu spät: http://www.delphipraxis.net/internal...076233#1076233 :tongue:

[Wolfgang Mix]

alzaimar hat folgendes geschrieben:

Zitat:

Und hier eine kürzere Testvariante:

Delphi-Quellcode:

KleinsterWert := Math.MinIntValue(zahlArray);

... für Fortgeschrittene ;-)

Gruß

Wolfgang

[alzaimar]

Zitat:

Zitat von Wolfgang Mix

... für Fortgeschrittene ;-)

Eher umgekehrt: Deine Version muss man erstmal verstehen, meine nicht. :mrgreen:

[Wolfgang Mix]

@alzaimar:

Meinst du damit, ich sollte den Quellcode noch kommentieren?

Gruß

Wolfgang

[Foxi1896]

Hey,
ich wollte mal Fragen was in meinem Code hier Falsch ist habe einfach nur ein paar Sachen ersetzt.
Er gibt mir bei Min totalen Unfug aus.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
 var zahl : array[1..1000] of integer;
  i,min,merker:integer;
  R1, R2, R3, R4, R5, R6, R7, R8 : Real;
begin
R1 := StrToFloat(Edit1.Text);
R2 := StrToFloat(Edit2.Text);
R3 := StrToFloat(Edit3.Text);
R4 := StrToFloat(Edit4.Text);
R5 := StrToFloat(Edit5.Text);
R6 := StrToFloat(Edit6.Text);
R7 := StrToFloat(Edit7.Text);
R8 := StrToFloat(Edit8.Text);


R1 := zahl [0];
R2 := zahl [1];
R3 := zahl [2];
R4 := zahl [3];
R5 := zahl [4];
R6 := zahl [5];
R7 := zahl [6];
R8 := zahl [7];


   min:=1000;
   for i:= 1 to 9 do
   begin
     if zahl[i] < min then
     begin
       min:=zahl[i];
       merker:=i;
     end;
   end;
   label1.caption:=IntToStr(min);
   label2.caption:=IntToStr(merker);
end;

und warum kann ich bei var nicht Array of Real machen?
var zahl : array of Real;

[DeddyH]

Zuerst belegst Du die Variablen mit Inhalten aus Edit-Feldern, im Anschluss überschreibst Du sie wieder mit dem, was im nicht initialisierten Array steht. Außerdem greifst Du auf Index 0 des Arrays zu, den es laut Definition gar nicht gibt, da das Array von 1 bis 1000 geht. Und da soll etwas anderes als Schrott bei herauskommen?

[Foxi1896]

ok das mit dem 1..1000 hab ich ja versucht zu ändern da ging gar nichts =/
Frage wie muss ich es machen damit es sinn ergibt?

[DeddyH]

Was willst Du denn erreichen?

[baumina]

Natürlich kannst du ein array of real machen. Mit "Array of Real" machst du ein dynamisches Array und musst natürlich dann für die Größe sorgen. Mit "Array[1..1000] of Real" machst du ein statisches Array, das max. 1000 Werte haben kann.

Das hier z.B. würde Sinn machen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
  var zahl : array[1..8] of real;
  i,merker : Integer;
  min      : Real;

begin
  zahl[1] := StrToFloat(Edit1.Text);
  zahl[2] := StrToFloat(Edit2.Text);
  zahl[3] := StrToFloat(Edit3.Text);
  zahl[4] := StrToFloat(Edit4.Text);
  zahl[5] := StrToFloat(Edit5.Text);
  zahl[6] := StrToFloat(Edit6.Text);
  zahl[7] := StrToFloat(Edit7.Text);
  zahl[8] := StrToFloat(Edit8.Text);

  min:=1000;
  for i:= 1 to 8 do
  begin
    if zahl[i] < min then
    begin
      min:=zahl[i];
      merker:=i;
    end;
  end;
  label1.caption:=FloatToStr(min);
  label2.caption:=IntToStr(merker);
end;

[Foxi1896]

Ich möchte das er mir sagt wo sich der kleinste Wert befindet.

Hatte es letzte Woche schonmal Versucht aber irgendwie war das doch flasch. Ich möchte den kleinsten Wert in den Edits ausfindig machen und dann die Reihenfolge bei ihm beginnen lassen.

z.B. 4 , 8 , 10 , 3 , 7 , 9 da ist die der kleinste Wert also soll 3 , 7 , 9 , 4 , 8 , 10 ausgegeben werden.

[DeddyH]

Dazu hatte ich doch schon eine komplette Lösung gepostet.

[Foxi1896]

Hatte es ja auch ... nur mein Betreuer möchte es mit den Edits haben.



Das hier ist schon fast so wie ich es haben möchte nur die Werte wo es wieder von vorne anfängt sind Falsch.

Habe es mit 5 , 8 , 14 , 3 , 8 , 10 , 16 , 20 getestet.
Raus kommt: 3 , 8 , 10 , 16 , 20 , 8,50548.. , 3,531622 , 1,370997...
Was macht er mit den Werten?

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
  var zahl : array[1..8] of real;
  i,merker : Integer;
  min : Real;

begin
  zahl[1] := StrToFloat(Edit1.Text);
  zahl[2] := StrToFloat(Edit2.Text);
  zahl[3] := StrToFloat(Edit3.Text);
  zahl[4] := StrToFloat(Edit4.Text);
  zahl[5] := StrToFloat(Edit5.Text);
  zahl[6] := StrToFloat(Edit6.Text);
  zahl[7] := StrToFloat(Edit7.Text);
  zahl[8] := StrToFloat(Edit8.Text);

  min:=1000;
  for i:= 1 to 8 do
  begin
    if zahl[i] < min then
    begin
      min:=zahl[i];
      merker:=i;
    end;
  end;
  label1.caption:=FloatToStr(min);
  label2.caption:=IntToStr(merker);

  Edit1.Text := FloatToStr(zahl[merker+0]);
  Edit2.Text := FloatToStr(zahl[merker+1]);
  Edit3.Text := FloatToStr(zahl[merker+2]);
  Edit4.Text := FloatToStr(zahl[merker+3]);
  Edit5.Text := FloatToStr(zahl[merker+4]);
  Edit6.Text := FloatToStr(zahl[merker+5]);
  Edit7.Text := FloatToStr(zahl[merker+6]);
  Edit8.Text := FloatToStr(zahl[merker+7]);


end;

EDIT: Hab den Fehler nur keine Lösung: ich zähle ja immer weiter mit +5 +6 +7 ... aber wie mach ich es das es wieder von vorne anfängt?

[DeddyH]

Schalt doch mal die Bereichsprüfung ein, dann siehst Du, dass Du locker hinter dem Array weiterliest. Und was das Ganze mit Edits zu tun haben soll, will mir nicht in den Kopf, dem Array ist es doch völlig wurscht, wo die Daten herkommen, ob aus Edits, einer ComboBox oder aus einer Datei ausgelesen.

[Foxi1896]

Wie schalte ich die Bereichsprüfung ein?
Ok, das mit dem Edits und so ist auch egal ... hab ich eingesehen.. ich benutze hier ja auch gerade Array.
Aber mir fehlt das know how für gewisse Befehle wie Bereichsprüfung. Verstehen tu ich schon halbwegs was hier steht nur die Ausführung.

[baumina]

Das ist jetzt zwar keine schöne Programmierung, aber so verstehst du es sicher am Besten:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
   var zahl : array[1..8] of real;
   i,merker : Integer;
   min : Real;

begin
   zahl[1] := StrToFloat(Edit1.Text);
   zahl[2] := StrToFloat(Edit2.Text);
   zahl[3] := StrToFloat(Edit3.Text);
   zahl[4] := StrToFloat(Edit4.Text);
   zahl[5] := StrToFloat(Edit5.Text);
   zahl[6] := StrToFloat(Edit6.Text);
   zahl[7] := StrToFloat(Edit7.Text);
   zahl[8] := StrToFloat(Edit8.Text);

   min:=1000;
   for i:= 1 to 8 do
   begin
     if zahl[i] < min then
     begin
       min:=zahl[i];
       merker:=i;
     end;
   end;
   label1.caption:=FloatToStr(min);
   label2.caption:=IntToStr(merker);

   i := merker; 
   Edit1.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit2.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit3.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit4.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit5.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit6.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit7.Text := FloatToStr(zahl[i]);

   i := i + 1;
   If i > 8 then i := 1; // dann vorne im Array anfangen
   Edit8.Text := FloatToStr(zahl[i]);


end;

[DeddyH]

In den Projektoptionen unter "Compilieren" lässt sich u.A. die Bereichsprüfung einschalten. Und hier dann noch meine angepasste Routine für Fließkommazahlen und dynamische Arrays:

Delphi-Quellcode:

type
  TDoubleArray = array of double;

procedure MinimumFirst(const Src: TDoubleArray; out Dest: TDoubleArray);
var
  (* Variable für die kleinste Zahl im Array *)
  Minimum: double;
  (* Variable für den Index der kleinsten Zahl innerhalb des Array *)
  IndexOfMinimum: integer;
  (* Laufvariable für die Schleife *)
  i: integer;
  (* aktueller Index im Zielarray *)
  DestIndex: integer;
begin
  Assert(Length(Src) > 0, 'Ein leeres Array hat keinen Minimalwert');
  (* Ausgabe auf gleiche Länge wie Eingabe setzen *)
  SetLength(Dest, Length(Src));
  (* Initial setzen wir Minimum sowie dessen Index auf das erste Element im Array *)
  Minimum := Src[Low(Src)];
  IndexOfMinimum := Low(Src);
  (* Nun den Rest des Array durchgehen, vergleichen und Variablen ggf. anpassen *)
  for i := Low(Src) + 1 to High(Src) do
    if Src[i] < Minimum then
      begin
        Minimum := Src[i];
        IndexOfMinimum := i;
      end;
  DestIndex := Low(Dest);
  (* Nun in das Ausgabe-Array schreiben *)
  (* Zuerst ab der kleinsten Zahl bis zum Ende *)
  for i := IndexOfMinimum to High(Src) do
    begin
      Dest[DestIndex] := Src[i];
      inc(DestIndex);
    end;
  (* Nun noch die ggf. verbliebenen *)
  for i := Low(Src) to IndexOfMinimum - 1 do
    begin
      Dest[DestIndex] := Src[i];
      inc(DestIndex);
    end;
end;

(* Testaufruf *)
procedure TFormTest.ButtonTestClick(Sender: TObject);
var
  zahl, Dest: TDoubleArray;
  d: double;
begin
  SetLength(zahl, 8);
  try
    zahl[0] := StrToFloat(Edit1.Text);
    zahl[1] := StrToFloat(Edit2.Text);
    zahl[2] := StrToFloat(Edit3.Text);
    zahl[3] := StrToFloat(Edit4.Text);
    zahl[4] := StrToFloat(Edit5.Text);
    zahl[5] := StrToFloat(Edit6.Text);
    zahl[6] := StrToFloat(Edit7.Text);
    zahl[7] := StrToFloat(Edit8.Text);
  
    MinimumFirst(zahl, Dest);
  
    Edit1.Text := FloatToStr(Dest[0]);
    Edit2.Text := FloatToStr(Dest[1]);
    Edit3.Text := FloatToStr(Dest[2]);
    Edit4.Text := FloatToStr(Dest[3]);
    Edit5.Text := FloatToStr(Dest[4]);
    Edit6.Text := FloatToStr(Dest[5]);
    Edit7.Text := FloatToStr(Dest[6]);
    Edit8.Text := FloatToStr(Dest[7]);
  finally
    zahl := nil;
    Dest := nil;
  end;
end;

[edit] Seid Ihr sicher, dass es sinnvoll ist, min mit einem fixen Wert vorzubelegen? Wenn alle Zahlen im Array > 1000 sind, gibt es keinen Minimalwert, das ist aber nicht schön. [/edit]

[Foxi1896]

@baumina: Danke, stimmt so verstehte ich es =)
Was könnte man den machen um es profensioneller aussehen zu lassen (auch wenn es mir eigentlich egal ist wie es aussieht.

@DeddyH: Geht das auch bei Lazarus? Hab gerade mal in den Einstellungen geschaut und finde nichts was dem entspricht.

Wenn es eine leichte Methode gibt. Nicht Abhängig vom Fixen Wert zu sein wäre es super. Wenn nicht auch egal bau ich halt eine zweiten/dritten Button ein (Meine Werte könnten 8 , 12 , 16 werden.)

[baumina]

Professioneller ist sicherlich DeddyH's Lösung. An der ist meines Erachtens nichts auszusetzen.

[Foxi1896]

DANK EUCH!!!
Jetzt versteh ich glaube auch die andere Variante.

[DeddyH]

Danke für die Blumen, ich habe den Code trotzdem noch leicht modifiziert. Leider konnte ich nicht herausfinden, wie man bei Lazarus die Breichsprüfung aktiviert bzw. deaktiviert, vermutlich geht es über Compilerschalter.