Bubblesort Problem

[GreyFox23]

Guten Abend,

momentan programmieren wir in der Schule einen Bubblesort-Algorithmus, der uns zufällig erzeugte Zahlen sortieren soll.
Ich sitze nun vor folgendem Problem:
Meine Bs-Algorithmus sortiert immer richtig, nur lässt er die höchste Zahl weg und überträgt auch nichts in StrinGrid (in welchem die sortierten Zahlen angezeigt werden sollen).
Wenn nun z.B. zufällige Zahlen von 1-100 gewählt werden, 10 an der Zahl: 87,62,25,12,19,2,45,98,57,98, wird in diesem Szenario die beiden 98 nicht mitsortiert, d.h. sie werden einfach ignoriert.

Hier mein Quellcode

Code:

procedure TBubblesortForm.SortButtonClick(Sender: TObject);
begin
  for i:=0 to high(numbers)-1 do
  begin
    for k:=i+1 to high(numbers) do
    begin
    if numbers[i]>numbers[k] then
        begin
        bubble:=numbers[k];
        numbers[k]:=numbers[i];
        numbers[i]:=bubble;
        snumbers[i]:=numbers[i];
        BubbleStringGrid2.cells[0,i-1]:=IntToStr(snumbers[i]);
        end;
      end;
  end;
end;

Ich hoffe man kann mir helfen.

MfG

[amoibos]

Überleg dir mal was du wann ausgibst, anders ausgedrückt 10 - 9 = 0?

[GreyFox23]

Zitat:

Zitat von amoibos (Beitrag 1317658)

Überleg dir mal was du wann ausgibst, anders ausgedrückt 10 - 9 = 0?

Tut mir leid, ist schon spät, ich weiß nicht genau was du damit meinst :(

[Namenloser]

Hi,

du gibst nur etwas im StringGrid aus, wenn

Delphi-Quellcode:

numbers[i]>numbers[k]

. Beachte: i ist höchstens high(numbers)-1 und k ist höchstens high(numbers). Was macht dein Code (nicht), wenn die letzte Zahl im Array die größte ist?

[hathor]

In einer Demo von DELPHI sieht der Code so aus:

Delphi-Quellcode:

procedure TSortThread.VisualSwap(A, B, I, J: Integer);
begin
  FA := A;
  FB := B;
  FI := I;
  FJ := J;
  Synchronize(DoVisualSwap);
end;

procedure TBubbleSort.Sort(var A: array of Integer);
var
  I, J, T: Integer;
begin
  for I := High(A) downto Low(A) do
    for J := Low(A) to High(A) - 1 do
      if A[J] > A[J + 1] then
      begin
        VisualSwap(A[J], A[J + 1], J, J + 1);
        T := A[J];
        A[J] := A[J + 1];
        A[J + 1] := T;
        if Terminated then Exit;
      end;
end;

[EWeiss]

greife das Thema mal auf da es bei mir auch um Bubblesort geht.

Delphi-Quellcode:

procedure BubbleSort(var zorder: array of Integer; var faceorder: array of Integer);
var
  IntI, IntK: Integer;
begin

  for IntI := Low(zorder) to (High(zorder) - 1) do
  begin
    for IntK := (IntI + 1) to High(zorder) do
    begin
       if zorder[IntI] < zorder[IntK] then
       begin
         BubbleSwap(zorder[IntI], zorder[IntK]);
         BubbleSwap(faceorder[IntI], faceorder[IntK]);
       end;
    end;
  end;
end;

Delphi-Quellcode:

BubbleSort(zorder, faceorder);

Mein Problem ist folgendes

Im Array zorder können sich auch negative werte befinden.
Wenn sie negativ sind würden sich diese werte ändern.

bsp.
zorder[IntI] := -18;
zorder[IntK] := -90;

in dem fall würde sich das Array ändern
weil -18 mehr wie -90 ist.

Das führt aber beim zeichnen zu Problemen da die ZOrder des Objects dann verändert wird.
Denn -90 ist ja eigentlich wenn ich zeichne mehr wie -18. (es liegt tiefer im Raum)

Wie kann ich das beheben? Oder ist meine Denkweise falsch.
Wenn also die Zorder wie im Bild -6 mehr wie -78 ist dann habe ich ein großes Problem.

gruss

[Delphi.Narium]

Bin mir nicht sicher, ob ich Dich richtig verstanden habe.

Gewünscht ist nicht: -90 -45 -30 -15 -7 0 7 15 30 45 90
sondern: -7 -15 -30 -45 -90 0 7 15 30 45 90

Oder mal ein Versuch es zu formulieren:

Zuerst mit dem vorhandenen BubbleSort sortieren.

Dann den ersten Wert suchen, der >= 0 ist.

Anschließend den Teil des Arrays, der vor diesem Wert liegt, absteigend sortieren.

Ungetestete Idee:

Delphi-Quellcode:

procedure BubbleSort(var zorder: array of Integer; var faceorder: array of Integer);
var
  IntI, IntK: Integer;
  IntM : Integer;
begin

  for IntI := Low(zorder) to (High(zorder) - 1) do
  begin
    for IntK := (IntI + 1) to High(zorder) do
    begin
       if zorder[IntI] < zorder[IntK] then
       begin
         BubbleSwap(zorder[IntI], zorder[IntK]);
         BubbleSwap(faceorder[IntI], faceorder[IntK]);
       end;
    end;
  end;

  for IntM := Low(zorder) to (High(zorder)) do
  begin
    if zorder[IntM] >= 0 then break;
  end;
  IntM := IntM - 1;
  
  for IntI := Low(zorder) to (IntM - 1) do
  begin
    for IntK := (IntI + 1) to IntM do
    begin
       if zorder[IntI] > zorder[IntK] then
       begin
         BubbleSwap(zorder[IntI], zorder[IntK]);
         BubbleSwap(faceorder[IntI], faceorder[IntK]);
       end;
    end;
  end;
end;

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1395376)

Delphi-Quellcode:

if zorder[IntI] < zorder[IntK] then {swap}

bsp.
zorder[IntI] := -18;
zorder[IntK] := -90;

in dem fall würde sich das Array ändern
weil -18 mehr wie -90 ist

Aber das Array würde sich doch nur ändern, wenn I (= - 18) kleiner als K (= -90) wäre, was ja nicht der Fall ist. Oder verstehe ich das Problem falsch?

[Delphi.Narium]

Zitat:

Zitat von Zacherl (Beitrag 1395384)

... wenn I (= - 18) kleiner als K (= -90) wäre ...

Vermute, dass es genau so sein soll.

Das liefe auf eine absteigende Sortierung für die Werte < 0 und eine aufsteigende Sortierung für die Werte > 0 hinaus, wobei die 0 zwischen diesen beiden Teilbereichen zu liegen kommt.

[Delphi-Laie]

Zitat:

Zitat von EWeiss (Beitrag 1395376)

Wenn also die Zorder wie im Bild -6 mehr wie -78 ist dann habe ich ein großes Problem.

Dann sortiere doch einfach nach den Beträgen (Absolutwerten ohne Vorzeichen)!