Probleme beim sortieren

[SnuffMaster23]

Hallo,

ich hab da ein kleines Problem mit dem SelectionSort-Algorithmus. Das Tut von Daniel hab ich mir durchgelesen.
Es geht darum, folgende kleine Liste (in TListBox) zu sortieren:

Code:

100 x 100 - 256 Farben
16 x 16 - 16 Farben
48 x 48 - 256 Farben
32 x 32 - 7 Farben
16 x 16 - 256 Farben
48 x 48 - 16 Farben
32 x 32 - 16 Farben
32 x 32 - 24 bpp
16 x 16 - 24 bpp
32 x 32 - 256 Farben
48 x 48 - 24 bpp

Die Einträge sollen primär nach Bildgröße und innerhalb gleicher Größe nach Farbtiefe sortiert werden.

Mein Algo sieht bisher so aus:

Delphi-Quellcode:

function SortList(List: TStrings): TStrings;
var
  i, j, min: Integer;
  Buffer   : string;
begin
  for i := 0 to List.Count - 2 do
  begin
    min := 0;
    for j := i + 1 to List.Count - 1 do
      if StrToInt(copy(List[j], 0, Pos(' ', List[j]) - 1)) < StrToInt(copy(List[min], 0, Pos(' ', List[min]) - 1)) then min := j;
    Buffer    := List[i];
    List[i]   := List[min];
    List[min] := Buffer;
  end;
  Result := List;
end;

(Richtig, das mit der Farbtiefe hab ich noch nicht implementiert)

Aufgerufen wird er so:

Delphi-Quellcode:

procedure TForm1.ListBox1Click(Sender: TObject);
var List: TStringList;
begin
  List := TStringList.Create;
  List.Assign(ListBox1.Items);
  Listbox1.Items.Assign(SortList(List));
end;

Der sortiert, aber nicht komplett:

• Der Eintrag mit 100 x 100 ist IMMER ganz oben, unabhängig von der Ausgangsposition
• Wenn ich mehrmals hintereinander auf die ListBox klicke wirds richtig komisch: Bei jedem zweiten Klick ist einer der 16 x 16-Einträge der letzte, bei den Klicks dazwischen tummeln sich alle 16 x 16 weiter oben auf einem Haufen.

Wo ist da der Wurm drin? http://snuffmaster23.wspace.org/smileys/Wurm.gif

[marabu]

Herzlich willkommen in der Delphi-PRAXiS, Snuffi.

Vergleiche deinen Code mit der von mir korrigierten Fassung:

Delphi-Quellcode:

function SortList(List: TStrings): TStrings;
var
  i, j, min: Integer;
  Buffer: String;
begin
  for i := 0 to List.Count - 2 do
  begin
    min := i; // nicht immer 0 setzen
    for j := i + 1 to List.Count - 1 do
      if StrToInt(copy(List[j], 1, Pos(' ', List[j])-1)) // Copy() ab Position 1
          < StrToInt(copy(List[min], 1, Pos(' ', List[min])-1)) then // ditto
        min := j;
    if min <> i then  // tauschen wenn nötig 
    begin
      Buffer    := List[i];
      List[i]   := List[min];
      List[min] := Buffer;
    end;
  end;
  Result := List;
end;

Freundliche Grüße vom marabu

[SnuffMaster23]

Hi marabu,
freundliche Grüße zurück...

Der korrigierte Code scheint zu funktionieren...
nein, der funktioniert!! http://SnuffMaster23.wspace.org/smileys/Nostalgic1.gifhttp://SnuffMaster23.wspace.org/smileys/Nostalgic1.gifhttp://SnuffMaster23.wspace.org/smileys/Nostalgic1.gifhttp://SnuffMaster23.wspace.org/smileys/Nostalgic1.gif

Das mit min := i statt 0 hab ich übersehen... (<- Syncron-Head-Nutting )
Ich glaub, copy wär des egal ob du bei 0 oder 1 anfängst, bin mir aber net sicher.
Und das bedingte Tauschen wär bei der Datenmenge auch nicht unbedingt nötig gewesen...

Danke Mann!!

[SnuffMaster23]

Hi Leute,

ich habs jetzt (ganz) anders gemacht:

Mit diesen Typen/Variablen...

Delphi-Quellcode:

type

  TIconInfo = record
    Size    : Word;
    BitCount: Byte;
  end;


var
  IconInfos    : array[Byte] of TIconInfo;
  IconCount    : Integer;

...diese (hardgecodete) Liste...

Delphi-Quellcode:

  IconInfos[0].Size      := 100;
  IconInfos[0].BitCount  := 8;
  IconInfos[1].Size      := 16;
  IconInfos[1].BitCount  := 4;
  IconInfos[2].Size      := 48;
  IconInfos[2].BitCount  := 8;
  IconInfos[3].Size      := 32;
  IconInfos[3].BitCount  := 3;
  IconInfos[4].Size      := 16;
  IconInfos[4].BitCount  := 8;
  IconInfos[5].Size      := 48;
  IconInfos[5].BitCount  := 4;
  IconInfos[6].Size      := 32;
  IconInfos[6].BitCount  := 4;
  IconInfos[7].Size      := 32;
  IconInfos[7].BitCount  := 24;
  IconInfos[8].Size      := 16;
  IconInfos[8].BitCount  := 24;
  IconInfos[9].Size      := 16;
  IconInfos[9].BitCount  := 7;
  IconInfos[10].Size     := 32;
  IconInfos[10].BitCount := 8;
  IconInfos[11].Size     := 48;
  IconInfos[11].BitCount := 24;

  IconCount              := 12;

...mit diesem Code sortieren:

Delphi-Quellcode:

function SortList(var IconList: array of TIconInfo): TStrings;
var
  i, j, min: Integer;
  SwBuffer : TIconInfo;
  List     : TStringList;
  StrBuffer: string;
begin
  List := TStringList.Create;
  for i := 0 to IconCount - 2 do                                                      //
  begin                                                                               // Array sortieren
    min := i;                                                                         //
    for j := i + 1 to IconCount - 1 do                                                //
      if (IconList[j].Size shl 8 or IconList[j].BitCount) < (IconList[min].Size shl 8 or IconList[min].BitCount) then
        min := j;                                                                     //
    if min <> i then                                                                  //
    begin                                                                             //
      SwBuffer      := IconList[i];                                                   //
      IconList[i]   := IconList[min];                                                 //
      IConList[min] := SwBuffer;                                                      //
    end;                                                                              //
  end;                                                                                //

  for i := 0 to IconCount - 1 do                                                                      //
  begin                                                                                               //  sortierte Liste ausgabefähig machen
    StrBuffer := IntToStr(IconList[i].Size) + ' x ' + IntToStr(IconList[i].Size) + ' - ';             //  (In StrngList umwandeln)
    case IconList[i].BitCount of                                                                      //
      0..8: StrBuffer := StrBuffer + IntToStr(Round(Power(2, IconList[i].BitCount))) + ' Farben';     //
      24  : StrBuffer := StrBuffer + '24 bpp';                                                        //
      else StrBuffer := StrBuffer + '?? Farben'                                                       //
    end;                                                                                              //
    List.Add(StrBuffer);                                                                              //
  end;                                                                                                //
  Result := List;
end;

Delphi-Quellcode:

procedure TForm1.ListBox1Click(Sender: TObject);
begin
  Listbox1.Items.Assign(SortList(IconInfos));
end;

Das Programm kann mit den Daten dies hier sortiert viel mehr anfangen als mit den Strings . Außerdem hab ich so alles auf einmal sortiert.