Arrayzugriff nimmt irgendwelche Wahllos-Variableninhalte aus Speicher

[JanWe]

Guten Morgäään, (oh, man ... die halbe Nacht steppe ich nun schon durch diese paar lächerlichen Zeilen dämlichen Code - *rote Augen reib*)

derzeit weiß ich nicht, wie ich das besser beschreiben soll (müde).
Ich möchte mit dem SelectionSort Algorithmus mein Array sortieren.
Dazu hab ich mir eine zweite "Indexvariable" implemetiert:
SortListNumber.
Nur diese wird verändert - nicht die ganzen Felderinhalte verschoben.

so in ner andern Funktion ist Form1.DynARray[J].SortListNumber fortlaufend, incrementiert (Felder 0 bis 9 sind belegt mit "int" 0 bis 9 )

Doch aus irgendwelchen Gründen tauchen nachher, wenn ich später mal
for i := 0 to Form1.MyItemMax - 1 do
durch gehe sind manche Zahlen in SortListnumber (immer wieder, reproduzierbar ) 3575 statt 9 oder 24145 statt 4, ...
Bsp: 8,5, 7, 3575 , 3, 24145,2 ,0 , 1 , 6.
wenn ich die Schleife nochmaldurchgehe werden auch die anderen Ziffern nacheinander durch 24145 ersetzt....

d.h. der holt die wohl irgendwo aus dem Speicher.
Aber wo???



Form1.DynARray[i].MyItem;

Delphi-Quellcode:

procedure TDateienFORM.SORTButtonClick(Sender: TObject);
Var
k, tmp, HHH,  maxi, i, j, : Integer;
begin

maxi := Form1.MyItemMax; // verwendete/belegte Felder vom DynArray [0..1000]


for i := 0 to maxi - 1 do
begin
   hhh := Form1.DynARray[i].MyItem;  // MyItem => zu vergeleichendes Feld
   k := i;
                                                                       
   for j :=  i+ 1 to maxi - 1 do begin // +1

      if Form1.DynARray[J].MyItem < hhh then
      begin
         k := j;
         hhh := Form1.DynARray[J].SortListNumber;
      end;

   end;
   Form1.DynARray[k].SortListNumber := Form1.DynARray[i].SortListNumber;
   Form1.DynARray[i].SortListNumber := hhh;
end;
end;

die Algorithmus-Variablennamen (TMP, hhh, , k) sind leicht abgewandelt von dem Algorithmus, den ich irgendwann mal im Web gefunden jab. Quelle unbkeannt. Aber er müßte mit dem auf Wikipedia gefundenen Pseudocode identisch sein.
https://de.wikipedia.org/wiki/Selectionsort (bin das vergleichend durchgegangen)

Sieht jemand meinen Denkfehler?
Danke - entschuldigt bitte meine Problem-Beschreibung. Bin noch Delphi-newbie.

[CarlAshnikov]

Was mir beim drüberlesen auffällt ist, dass du, wenn kein Eintrag gefunden wird, HHH aus Form1.DynARray[i].MyItem befüllst, es aber in Form1.DynARray[i].SortListNumber reinschreibst.

[Zoot]

Deine Variable hhh stellt einmal den Wert des Elementes, einmal die Sortierreihenfolge dar. Das solltest du dir nochmal näher anschauen, am besten unterschiedliche Variablen verwenden.

[Zoot]

Zitat:

Zitat von CarlAshnikov (Beitrag 1298451)

Was mir beim drüberlesen auffällt ist, dass du, wenn kein Eintrag gefunden wird, HHH aus Form1.DynARray[i].MyItem befüllst, es aber in Form1.DynARray[i].SortListNumber reinschreibst.

Richtig. Und selbst wenn ein Eintrag gefunden wurde, wird ab da nicht mehr mit "MyItem" verglichen, sondern mit der Sortiernummer, was gar keinen Sinn ergibt.

[himitsu]

Zum Problem wurde ja schon Einiges gesagt, also nun noch was zum Design:

Du verwendest in dieser Methode ausschließlich Variablen von Form1.
Warum ist liegt dieser Code also nicht in einer "Sortier"-Methode von Form1, welche über SORTButtonClick aufgerufen wird?

[Sir Rufo]

Wem ist denn der Fehler in dem Wikipedia-Code aufgefallen? ;)

[himitsu]

?

1. Wiki hat immer Recht.
2. Sollte sie nicht Recht haben, dann gilt Punkt 1.
3. Im Zweifel fragt man den G. und der sagt Wiki habe Recht.

[Sir Rufo]

Wenn wir den Wikipedia-Pseudeo-Code mal nach Delphi übersetzen (das geht quasi 1:1, denn das riecht nach gedeutschtem Pascal)

Code:

prozedur SelectionSort( A : Liste sortierbarer Elemente ) 
  n = Länge( A )
  links = 0
  wiederhole
    min = links
    für jedes i von links + 1 bis n wiederhole 
      falls A[ i ] < A[ min ] dann
          min = i
      ende falls
    ende für
    Vertausche A[ min ] und A[ links ]
    links = links + 1
  solange links < n
prozedur ende

in Delphi (aber falsch)

Delphi-Quellcode:

procedure SelectionSort( var A : TArray<Integer> );
var
  n, i, links, min : Integer;
  temp : Integer;
begin
  n := Length( A );
  links := 0; // soso, das erste Element hat den Index 0 :o)
  repeat
    min := links;
    for i := links + 1 to n do
    begin
      if A[ i ] < A[ min ] then
        min := i:
    end;
    
    temp := A[ links ];
    A[ links ] := A[ min ];
    A[ min ] := temp;

    links := links + 1;
  until not( links < n );
end;

und nun mal richtig

Delphi-Quellcode:

procedure SelectionSort( var A : TArray<Integer> );
var
  n, i, links, min : Integer;
  temp : Integer;
begin
  n := High( A );
  links := Low( A );
  while links < n do
  begin
    min := links;
    for i := links + 1 to n do
    begin
      if A[ i ] < A[ min ] then
        min := i:
    end;
    
    if links <> min then
    begin
      temp := A[ links ];
      A[ links ] := A[ min ];
      A[ min ] := temp;
    end;

    links := links + 1;
  end;
end;

[himitsu]

Gut, die Schleife ist falschrum, aber solange die Liste nicht leer ist, knallt es auch nicht. :stupid:

Und das fehlende

Delphi-Quellcode:

if links <> min then

... sich selber mit sich austauschen ist zwar sinnlos, aber zumindestens nicht falsch. :angle:

[Sir Rufo]

Zitat:

Zitat von himitsu (Beitrag 1298485)

Gut, die Schleife ist falschrum, aber solange die Liste nicht leer ist, knallt es auch nicht. :stupid:

Und das fehlende

Delphi-Quellcode:

if links <> min then

... sich selber mit sich austauschen ist zwar sinnlos, aber zumindestens nicht falsch. :angle:

Das war eigentlich nur Makulatur, der größte Fehler ist, dass der 0-Index nicht berücksichtigt wird.
Bei 6 Elementen bekomme ich als Länge 6 zurück. Die Elemente spreche ich aber über 0..5 an und genau da liegt der Fehler in dem Pseudo-Code, der greift auch auf den Index 6 zu, was das 7. Element wäre, was es gar nicht gibt.

[JanWe]

grüß Euch,

mhh, habb jetztmehrmals was probiert ...
v.a. mit dem untenstehenden Code:

Zitat:

Zitat von Sir Rufo (Beitrag 1298482)

[...]
und nun mal richtig

Delphi-Quellcode:

procedure SelectionSort( var A : TArray<Integer> );
var
  n, i, links, min : Integer;
  temp : Integer;
begin
  n := High( A );
  links := Low( A );
  while links < n do
  begin
    min := links;
    for i := links + 1 to n do
    begin
      if A[ i ] < A[ min ] then
        min := i:
    end;
    
    if links <> min then
    begin
      temp := A[ links ];
      A[ links ] := A[ min ];
      A[ min ] := temp;
    end;

    links := links + 1;
  end;
end;

ich hab A[] mal gegen DYNarray ausgetauscht und Links NUll gesetzt, weil das das niedrigste Feld im Array ist.

Delphi-Quellcode:

procedure SelectionSort( A : Integer ); // hab die direkte Übergabe momentan gestrichen - war mir zu kompliziert.
var
  n, i, links, min : Integer;
zahl1, zahl2,  temp : Integer;
begin
  n := form1.Bildmax;
  links := 0 ;
  while links < n do
  begin
    min := links;
    for i := links + 1 to n do
    begin
      if Form1.DynARray[ i ].Kriterium < Form1.DynARray[ min ].Kriterium then
        min := i;
    end;

    if links <> min then
    begin
      temp := Form1.DynARray[ links ].SortListNumber;
      Form1.DynARray[ links ].SortListNumber := Form1.DynARray[ min ].SortListNumber;
      Form1.DynARray[ min ].SortListNumber := temp;
    end;

    links := links + 1;
  end;
end;

So (Kriterium wird in der Position NICHT VERSCHOBEN !!!! nur die SortListNummer!!):
Durchgeang 1 : Original reihenfolge VOR dem Sortieren
[Code]
SortListNummer; OriginalPlatzNummer; Kriterium
0 0 80171
1 1 63091
2 2 487258
3 3 3735
4 4 24149
5 5 24149
6 6 24149
7 7 5863
8 8 242816
9 9 24039
___________________________
Nach Sortieren: (1x geklickt)
0 0 80171
0 1 63091
1 2 487258
2 3 3735
3 4 24149
4 5 24149
5 6 24149
6 7 5863
7 8 242816
8 9 24039
-------------------------

So kommt jetzt die zweite 0 her? und warum fehlt die 9?

[himitsu]

Zuerst könnte man ja mal auf die saudumme Idee kommen und in den Projektoptionen die Indexprüfung aktivieren. :roll:

[JanWe]

Zitat:

Zitat von himitsu (Beitrag 1298792)

Zuerst könnte man ja mal auf die saudumme Idee kommen und in den Projektoptionen die Indexprüfung aktivieren. :roll:

Grüß Dich himitsu,

mhh, ja, kannste nicht wissen .. ich hab nur Delphi 5
da is das wohl noch nich vorgesehn (s. Screenshot).

Hab jetzt einfach nochmal ein wenig durchgesteppt (obwohl .. bei 100x F7 wirste auch langsam ... :D)
naja
und jedenfalls mal n-1 gesetzt - (ob das jetzt algorithmisch sinnvoll/richtig ist, weiß ich nicht.)
Aber wenigstens verschwindet nicht mehr die 9 und die Null taucht nur 1x auf.

Delphi-Quellcode:

procedure SelectionSort( A : Integer );
var
  n, i, links, min : Integer;
 temp : Integer;
begin
  n := 10 ; // anzahl der Kriterien
  links := 0 ;
  while links < n do
  begin
    min := links;
    for i := links + 1 to n [b]-1[/b]  do
    begin
      if Form1.DynARray[ i ].Kriterium < Form1.DynARray[ min ].Kriterium then
        min := i;
    end;

    if links <> min then
    begin
      temp := Form1.DynARray[ links ].SortListNumber;
      Form1.DynARray[ links ].SortListNumber := Form1.DynARray[ min ].SortListNumber;
      Form1.DynARray[ min ].SortListNumber := temp;
    end;

    links := links + 1;
  end;
end;

Allerdings find ich nicht, daß die Vergleiche sinnvoll stattgefunden haben....

SortierListNR (neu sortiert); TAB OriginalPosition ; TAB Kriterium
3 0 80171
0 1 63091
1 2 487258
2 3 3735
7 4 24149
4 5 24149
5 6 24149
6 7 5863
9 8 242816
8 9 24039

denn sortiert is da irgendwie nix:
SortierListNR; TAB OriginalPosition (neue Pos) ; TAB Kriterium (neue Pos)
0 1 63091
1 2 487258
2 3 3735
3 0 80171
4 5 24149
5 6 24149
6 7 5863
7 4 24149
8 8 242816
9 9 24039


wenn ich das hiermit ausgebe.

Delphi-Quellcode:

for i := 0 to 9  do
begin
a := form1.DynARray[i].SortListNumber;
memo3.lines[a] :=(
inttostr(form1.DynARray[i].SortListNumber) + #9 +
inttostr(form1.DynARray[i].Originalnummer) + #9 +
inttostr(form1.DynARray[i].Kriterium) + #9 + ''
);

[Dalai]

Himitsu meinte die Überlaufprüfung und/oder die Bereichsprüfung, schätze ich mal, und die gibt's beide auch im Delphi 5.

MfG Dalai

[TRomano]

Ist die auf dem Screenshot abgebildete Bereichsüberprüfung nicht die "Index-Überprüfung" ... ?

zu spät ...

[JanWe]

Zitat:

Zitat von TRomano (Beitrag 1298801)

Ist die auf dem Screenshot abgebildete Bereichsüberprüfung nicht die "Index-Überprüfung" ... ?

zu spät ...

ich hab die dann einfach mal ausprobiert, als der davon schrieb - bevor ich eben gepostet hatte.

Delphi hatte aber jeweils keine Meldung ausgegeben - auch nicht, als noch n ohne n-1 stand.
Darum dachte ich, er meint was anderes.

aber daß da nur was vertauscht, aber nicht sortiert wird, - is schon komisch.
Ich hab einfach nur den Code von Sir Rufo genommen
und eine Variablennamen da eingefügt. (so, wie ich das verstanden hatte. Und eigntlich seh ich da auch keinen Fehler in dem Algorithmus. Also ich seh den nich. ...
http://www.delphipraxis.net/1298798-post13.html (mein Post)

[quaero]

Zitat:

Zitat von JanWe (Beitrag 1298798)

Delphi-Quellcode:

    if links <> min then
    begin
      temp := Form1.DynARray[ links ].SortListNumber;
      Form1.DynARray[ links ].SortListNumber := Form1.DynARray[ min ].SortListNumber;
      Form1.DynARray[ min ].SortListNumber := temp;
    end;

    links := links + 1;
  end;
end;

Irgendwie wendest du den Algorithmus nicht wirklich an. Es geht darum, dass du das kleinste Element suchst und an den Anfang schiebst und dann im Rest weitersuchst.
Das, was du machst, ist aber, dir nur zu merken, welche beiden Elemente du tauschen müsstest (im ersten Schritt Element 3 auf 0 und 0 auf 3), ohne tatsächlich zu tauschen. Das führt dazu, dass das größere Element an der Stelle bleibt und nicht weiter beachtet wird, während das kleinste Element immer wieder gefunden und als Tauschpartner gefunden wird.
Entweder führst du den Tausch tatsächlich aus oder die passt die Suche nach dem kleinsten Element in der Weise an, dass immer alle 10 Elemente geprüft werden, aber nur, wenn deren SortListNumber > aktueller Index ist.

[BadenPower]

Der Code von Sir Rufo ist zum Sortieren eines Array gedacht und dazu müsstest Du die Arrayelemente verschieben.

Da Du aber scheinbar nicht das Array sortieren möchtest, entgegen der Überschrift, sondern nur die Rangfolge der Werte bestimmen möchtest und in SortListNumber hinterlegen ist dies nicht der richtige Algo für Dich.

Auf die Schnelle würde ich dies so lösen:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  liZ1: Integer;
  liZ2: Integer;
  lLowerCount: Integer;
  lHigh: Integer;
begin

  lHigh := Length(DynArray) - 1;

  for liZ1 := 0 to lHigh do
   begin
    lLowerCount := 0;
    for liZ2 := 0 to lHigh do
     begin
      if (DynArray[liZ2].Kriterium < DynArray[liZ1].Kriterium) then
       begin
        Inc(lLowerCount);
       end;
     end;
    DynArray[liZ1].SortListNumber := lLowerCount;
   end;

end;