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)!

[himitsu]

Dann mußt du eben nach mehreren Kriterien sortieren.

wenn Math.Sign ungleich ist, dann direkt vergleichen
und wenn Math.Sign gleich ist, mit Abs vergleichen.

[Zacherl]

Zitat:

Zitat von Delphi.Narium (Beitrag 1395385)

Zitat:

Zitat von Zacherl (Beitrag 1395384)

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

Vermute, dass es genau so sein soll.

Mhh, weiß jetzt nicht, um welche Z-Order es genau geht, aber meiner Erfahrung nach handelt es sich doch hier eigentlich immer um ganz normale 3-dimensionale Räume. Hier sollte auch die bekannte Ordnung der Elemente gelten, also (je nach Richtung) entweder kleinere Z-Werte = weiter hinten bzw. kleinere Z-Werte = weiter vorne. Dass es da einen Umbruch bei der Null gibt, wäre mir neu.

[Delphi.Narium]

Das mag durchaus so sein, ich hab' halt die Anforderung so verstanden, das es quasi von -1 nach -unendlich, 0, 1 nach unendlich gehen soll.

Aber wie oben schon geschrieben: Bin mir nicht sicher, ob ich die Anforderung richtig verstanden habe.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1395388)

Zitat:

Zitat von Delphi.Narium (Beitrag 1395385)

Zitat:

Zitat von Zacherl (Beitrag 1395384)

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

Vermute, dass es genau so sein soll.

Mhh, weiß jetzt nicht, um welche Z-Order es genau geht, aber meiner Erfahrung nach handelt es sich doch hier eigentlich immer um ganz normale 3-dimensionale Räume. Hier sollte auch die bekannte Ordnung der Elemente gelten, also (je nach Richtung) entweder kleinere Z-Werte = weiter hinten bzw. kleinere Z-Werte = weiter vorne. Dass es da einen Umbruch bei der Null gibt, wäre mir neu.

-18 ist aber größer laut der Berechnung von Bubblesort.
Das ist mein Problem weis nicht wie ich das verrechnen soll.

Ich habe 10 Objekte die sich im Kreis drehen.
Wenn sich diese im Vordergrund befinden dann soll das nächstfolgende das davor liegende überlagern.
Wenn das letzte Objekt hinten liegt in dem fall das 10 dann soll das folgende dieses überlagern.
Ist etwas kompliziert zu beschreiben.

wie man am Bild erkennen kann ist das alles etwas durcheinander. :wall:

Das grüne ist das höchste Element wenn sich dieses vorne befindet dann sollen alle nachfolgenden dieses überlagern
Wenn es sich hinten befindet sollen sich die folgenden dahinter setzen.

@Delphi.Narium
Kann dir den Source gern mal schicken damit du nachverfolgen kannst um was es mir geht. ;)
Oder jemanden anderen der es mal testen möchte.
Schick ne PN wenn du willst mit deiner MAIL..
Dein versuch funktioniert leider nicht.
Komme mit den minus werten nicht klar.

Im Bild das Blaue auf der linken Seite müsste vor dem grünen liegen
und das blaue vor dem orangen müsste das orange überlagern. usw.. LOL

gruss

[hoika]

Hallo,
ich würde das ganz pragmatisch angehen.
Schreibe Dir eine Compare-Methode.
Parameter sind 2 Integer-Werte, Ergebnis -1, 0, +1.

Dort definierst Du Deine Sortierkriterien:
Beide negativ oder beide positiv: vergleiche Abs-Werte
andernfalls: es reicht der direkte Vergleich

Das Rausziehen in eine eigene Compare-Methode macht es übersichtlicher.

[EWeiss]

Zitat:

ich würde das ganz pragmatisch angehen.

Das hört sich bei euch alles so einfach an.
Ist es aber nicht.. ;)

Denn was ich versuche ist ein Object in einem emulierten 3D Raum zu bewegen.
Die Z Order (Tiefe) wie bei 3D gibt es aber bekanntlich in 2D nicht.

gruss

[Neutral General]

Zitat:

Zitat von EWeiss (Beitrag 1395396)

Denn was ich versuche ist ein Object in einem emulierten 3D Raum zu bewegen.
Die Z Order (Tiefe) wie bei 3D gibt es aber bekanntlich in 2D nicht.

Ob jetzt 2D/3D, Tiefe, was-auch-immer ist egal.
Unterm Strich willst du nur eine Liste von Zahlen auf eine bestimmte Weise sortiert haben.
Wenn du weißt wie die Reihenfolge sein soll musst du dir dann überlegen wie die Kriterien zum Sortieren aussehen müssen - fertig.

Stimmt denn folgende Sortierung?

-7 -15 -30 -45 -90 0 7 15 30 45 90

Wäre gut wenn du da mal Beispielzahlen nennen würdest und in welcher Reihenfolge du sie genau haben willst.
Falls oben die Reihenfolge korrekt wäre musst du beim Vergleichen von 2 Zahlen schauen ob beide Zahlen negativ sind.
In dem Fall sortierst du absteigend, ansonsten aufsteigend.

[EWeiss]

Zitat:

Ob jetzt 2D/3D, Tiefe, was-auch-immer ist egal.

Es ist nicht egal ob ich 3 werte oder nur 2 zur Berechnung habe.

x,y,z ist wenn es um die tiefe eines Object geht angenehmer zu berechnen (3D Raum)
als wenn man nur über x,y verfügt.
Unter OpenGL ist das ein Klacks.

Man muss das plastisch sehen nur unfertige Projekte lade ich nicht gerne hoch.

Zitat:

-7 -15 -30 -45 -90 0 7 15 30 45 90

Nein.. Die Berechnung von @Delphi.Narium: funktioniert nicht.
Welche Reihenfolge kann ich nicht sagen da ich es nach Sichtbarkeit versuche zu korrigieren.
Vermute bald es es sich mit Bubblesort nicht machen lässt.

gruss

[Blup]

Dein Problem ist nicht das Sortieren, egal welche Sortiermethode angewendet wird.
Auch wenn die Darstellung 2D ist, für die Simulation eines 3D Raums müssen die Objekte 3 Koordinaten haben.

Weist du nicht wie die Tiefe der einzelne Objekte ermittelst?
Oder weist du nicht wie die Tiefe miteinander zu vergleichen ist?
Oder liegt ein ganz anderes Problem vor, auf das du noch nicht eingegangen bist?

[EWeiss]

Zitat:

Weist du nicht wie die Tiefe der einzelne Objekte ermittelst?

Doch!

Delphi-Quellcode:

GetClientRect(HSprCtrl, rc);
xcenter  := (rc.Right - 128) div 2;
ycenter  := (rc.Bottom - 128) div 2;
zcenter  := ycenter div 2;
radius   := round(rc.Right / 3.675);

Zitat:

Oder weist du nicht wie die Tiefe miteinander zu vergleichen ist?

Richtig!
Habe es mit Bubblesort versucht was aber anscheinend nicht geht.

gruss

[Neutral General]

[QUOTE=EWeiss;1395399]

Zitat:

Welche Reihenfolge kann ich nicht sagen da ich es nach Sichtbarkeit versuche zu korrigieren.
Vermute bald es es sich mit Bubblesort nicht machen lässt.

Dein Problem ist nicht der Sortieralgorithmus, sondern die Tatsache dass du gar nicht wirklich weißt was du haben willst.
Du musst wissen in welcher Reihenfolge du deine Zahlen haben willst und du musst wissen wie du deine Objekte mit Hilfe der sortierten Zahlen richtig darstellen kannst.
Und bei mindestens einem von beiden hakt es bei dir grad. Dir muss nur bewusst sein wo genau es hakt.
Es klingt nämlich grad danach als hätte dein eigentliches Problem nichts mit Sortieren zu tun.

Edit:

Zitat:

Oder weist du nicht wie die Tiefe miteinander zu vergleichen ist?
Richtig!
Habe es mit Bubblesort versucht was aber anscheinend nicht geht.

Bubblesort sortiert deine Zahlen so wie du sie haben willst. Bubblesort GEHT zu 100%.
Du musst nur wissen was du haben willst und entsprechend sortieren.

[EWeiss]

Zitat:

sondern die Tatsache dass du gar nicht wirklich weißt was du haben willst.

Das ich nicht weis wie ich es sortieren soll..
Richtig!

Mal der komplette part.

Delphi-Quellcode:

procedure DrawCarousel(WinHandle: HWND);
var
  K, I: Integer;
  Angle, anglePi: single;
  rc: TRect;
  speed, fl, z, scale: Single;
  xcenter, ycenter, zcenter: Integer;
  radius: Integer;
  x, y: Integer;
  PiDiv180: Double;
  zorder: array [0..9] of Integer;
  faceorder: array [0..9] of Integer;
begin
    if bAnimate then
    begin
       y      := trbY.GetTrackValue(trbY.Handle);
       speed  := trbSpeed.GetTrackValue(trbSpeed.Handle) div 4;
       fl     := trbFocallength.GetTrackValue(trbFocallength.Handle) / 100;

       if fl < 0.02 then
         fl := 0.001;
       PiDiv180 := 1.74532925199433E-2;

       GetClientRect(HSprCtrl, rc);
       xcenter  := (rc.Right - 128) div 2;
       ycenter  := (rc.Bottom - 128) div 2;
       zcenter  := ycenter div 2;
       radius   := round(rc.Right / 3.675);

       for K := High(zorder) downto 0 do
       begin
         Angle := gSpriteData[K].rAngle;
         anglePi := Angle * PiDiv180;
         z := sin(anglePi) * radius + zcenter;
         scale := fl / (fl + z);
         x := round(cos(anglePi) * radius);
         gSpriteData[K].xPos := round(x * scale + xcenter);
         gSpriteData[K].yPos := round(y * scale + ycenter - y);

         zorder[K] := round(Angle - 90);
         if zorder[K] > 180 then
           zorder[K] := 360 - zorder[K];

         faceorder[K] := K;

         if bMoveToLeft then
         begin
           Angle := Angle - speed;
           if Angle < 1 then
             Angle := 360
         end else
         begin
           Angle := Angle + speed;
           if Angle > 359 then
             Angle := Angle - 360;
         end;
         gSpriteData[K].rAngle := round(Angle);

         // Skalierungsfaktor berechnen
         if Check3Ddepth.GetCheckButtonStatus(Check3Ddepth.Handle) then
           gSprCtrl.GD_SetObjectScale(gSpriteData[K].ID, (ABS(zorder[K]) mod 182) * 0.0027777 + 0.5)
         else
         gSprCtrl.GD_SetObjectScale(gSpriteData[K].ID, 1);

         // Alpha Kanal unschalten
         if CheckOpacity.GetCheckButtonStatus(CheckOpacity.Handle) and (fl > 0.999) then
           gSprCtrl.GD_SetObjectAlpha(gSpriteData[K].ID, round(MIN(100 * scale, 255)), false)
         else
         gSprCtrl.GD_SetObjectAlpha(gSpriteData[K].ID, 255, false);

         gSprCtrl.GD_SetObjectXY(gSpriteData[K].ID, gSpriteData[K].xPos, gSpriteData[K].yPos);

         if CheckSelfRotation.GetCheckButtonStatus(CheckSelfRotation.Handle) then
           gSprCtrl.GD_SetObjectAngle(gSpriteData[K].ID, round(gSpriteData[K].rAngle), false)
         else
         gSprCtrl.GD_SetObjectAngle(gSpriteData[K].ID, 0, false);
       end;

       BubbleSort(zorder, faceorder);

       // Sprite ZOrder setzen
       I := faceorder[0];
       if bMoveToLeft then
       begin
         inc(I);
         if I > (ID_MAX_SPRITE - 1) then
           I := 0;
       end;

       gSprCtrl.GD_SetObjectZorder(gSpriteData[I].ID, GD_ORDER_BOTTOM);
       gSprCtrl.GD_SetObjectZorder(gSpriteData[faceorder[ID_MAX_SPRITE - 1]].ID, GD_ORDER_TOP);

       if CheckMarquee.GetCheckButtonStatus(CheckMarquee.Handle) then
         DrawMarquee(rc.Right);

       gSprCtrl.GI_UpdateWindow(HSprCtrl, false);
    end;
end;

Bubblesort habe ich schon gepostet.

gruss

[Blup]

Da liegt vermutlich das Problem:

Delphi-Quellcode:

 zorder[K] := round(Angle - 90);
 if zorder[K] > 180 then
   zorder[K] := 360 - zorder[K];

Gesucht wird eine Abbildung des Winkels auf die Tiefe in etwa so:

Code:

zorder
180 -       270°

090 -   0°      180°
    
000 -       90°

Ist natürlich abhängig davon wie das Koordinatensystem in Bezug auf den Betrachter ausgerichtet ist.

[EWeiss]

Zitat:

Zitat von Blup (Beitrag 1395434)

Da liegt vermutlich das Problem:

Delphi-Quellcode:

 zorder[K] := round(Angle - 90);
 if zorder[K] > 180 then
   zorder[K] := 360 - zorder[K];

Gesucht wird eine Abbildung des Winkels auf die Tiefe in etwa so:

Code:

zorder
180 -       270°

090 -   0°      180°
    
000 -       90°

Ist natürlich abhängig davon wie das Koordinatensystem in Bezug auf den Betrachter ausgerichtet ist.

Verstehe nicht was du mit der Abbildung sagen willst. sorry
Könntest du das bitte als Quelltext interpretieren ?

gruss

[Blup]

Die Objekte scheine in dem Projekt in einem Kreis vor dem Betrachter angeordnet.
Deshalb ist der Abstand vom Betrachter abhängig vom Winkel, in dem die Objekte angeordnet sind.
Gesucht wird eine Funktion die ein Information über den Tiefenabstand Z vom Betrachter liefert.

[Delphi-Laie]

Emil, brich doch das Problem bitte mal auf das wesentliche herunter!

Ständig wirfst Du 2D- und 3D-Koordinaten hier in den Raum (sind diese Informationen für die Hilfebemüher wirklich relevant?), obwohl es doch "nur" um das Sortieren eines eindimensionalen Arrays, also Vektors geht.

Ehrlich gesagt, habe ich Dein Problem bis jetzt nicht verstanden.

Irgendeine eindeutig bestimmte Reihenfolge müssen Deine Daten doch haben, ansonsten muß man sich über einen Sortieralgorithmus nicht einen Gedanken machen, weil dann ein solcher ins Leere liefe.

[EWeiss]

Zitat:

Ehrlich gesagt, habe ich Dein Problem bis jetzt nicht verstanden.

Ist auch schwierig zu verstehen.. bzw. schwer zu erklären ohne das man das Projekt in Aktion sieht.
Kurz gesagt die Objekte werden in der Reihenfolge (ZOrder) nicht richtig gezeichnet.

gruss

[TiGü]

Lös dein Problem doch erstmal auf Papier, dann kann man über eine Umsetzung reden.

[EWeiss]

Zitat:

Zitat von TiGü (Beitrag 1395452)

Lös dein Problem doch erstmal auf Papier, dann kann man über eine Umsetzung reden.

Versuche es gerade mit Pappe.
Oder sollte ich vielleicht doch Papier nehmen.. Hmmm :idea:
Sehe schon komme hier nicht weiter aber wird schon vielleicht bekomme ich noch einen Geistesblitz.

gruss

[madas]

Zitat:

Zitat von EWeiss (Beitrag 1395453)

Zitat:

Zitat von TiGü (Beitrag 1395452)

Lös dein Problem doch erstmal auf Papier, dann kann man über eine Umsetzung reden.

Versuche es gerade mit Pappe.
Oder sollte ich vielleicht doch Papier nehmen.. Hmmm :idea:
Sehe schon komme hier nicht weiter aber wird schon vielleicht bekomme ich noch einen Geistesblitz.

gruss

Meinst Du mit Z-Index sowas hier?

[Delphi-Laie]

Zitat:

Zitat von EWeiss (Beitrag 1395450)

Zitat:

Ehrlich gesagt, habe ich Dein Problem bis jetzt nicht verstanden.

Ist auch schwierig zu verstehen.. bzw. schwer zu erklären ohne das man das Projekt in Aktion sieht.

Nun, es ist wohl eher ein Problem, eine genaue Reihenfolge zu definieren.

Ein Bubblesort-Problem, wie die Überschrift ankündigt, ist es sicher nicht. Dieser Sortieralgorithmus ist nämlich so simpel, daß sich nahezu immer jemand im Forum findet, beim bloßen Anblick des Quellcodes den Fehler zu entdecken.

Ist die gewünschte Reihenfolge erstmal klar, kann man nämlich (nahezu) jeden Sortieralgorithmus auf jedes Sortierproblem loslassen.

Zitat:

Zitat von EWeiss (Beitrag 1395450)

Kurz gesagt die Objekte werden in der Reihenfolge (ZOrder) nicht richtig gezeichnet.

Und, bist Du Dir sicher, daß es daran liegt, daß die definierte bzw. gewünschte Reihenfolge nicht der tatsächlichen enspricht?

[madas]

Zitat:

Zitat von madas (Beitrag 1395458)

Zitat:

Zitat von EWeiss (Beitrag 1395453)

Zitat:

Zitat von TiGü (Beitrag 1395452)

Lös dein Problem doch erstmal auf Papier, dann kann man über eine Umsetzung reden.

Versuche es gerade mit Pappe.
Oder sollte ich vielleicht doch Papier nehmen.. Hmmm :idea:
Sehe schon komme hier nicht weiter aber wird schon vielleicht bekomme ich noch einen Geistesblitz.

gruss

Meinst Du mit Z-Index sowas hier?

Wenn Du Dir nun z.B. durch die beiden Kugel mit Z-Index 0 drauf die X-Achse denkst,
sollten alle Kugeln mit einem Y-Wert größer 0 einen negativen bzw. kleinen Z-Index bekommen
und alle Kugeln mit einem Y-Wert kleiner 0 einen positiven bzw. hohen Z-Index.
Nun sollte Dir auffallen, dass Du als Z-Index auch einfach den gleichen Wert, wie für den
der Y-Achse nehmen kannst bzw. den negierten Wert davon.

Beispiel (X, Y):

rote Kugel hat die KOs (50, -25), dann wäre der Z-Index einfach 25.
links orange hat die KOs (25, -12,5), dann wäre der Z-Index einfach 12,5.
links gelb hätte die KOs (8, 0), dann wäre der Z-Index einfach 0.
links mint-grün hätte (25, 17), dann wäre der Z-Index -17.
hinten türkis hätte (50, 25), dann wäre der Z-Index einfach -25.

usw.

hängt davon ab, wie Dein KO-System gestrickt ist.

madas

[EWeiss]

Genau so soll es sich drehen (bzw. die Anordnung sein) wie in deinem Bild gezeigt
Na ja werde mal schaun habe noch andere Baustellen.

gruss

[EWeiss]

Zitat:

Ist die gewünschte Reihenfolge erstmal klar, kann man nämlich (nahezu) jeden Sortieralgorithmus auf jedes Sortierproblem loslassen.

Leicht dahin gesagt..

Meine Reihenfolge wird in dem Quelltext definiert.
Welche werte dann im einzelnen entstehen ist abhängig von der Berechnung. (Position der Sprites im Raum)
Noch deutlicher kann man es nicht zeigen.

Wenn deine Aussage zutrifft "(nahezu) jeden" dann frage ich mich warum es dann nicht funktioniert.
Werde mich damit nochmal auseinandersetzen wenn ich meine anderen Baustellen beseitigt habe.

Die Realität ist nicht gleichzusetzen mit Vermutungen!

gruss

[himitsu]

Das Sortieren funktioniert vollkommen korrekt, entsprechend deinem Vergleichskriterium.

Da arbeiten alle Sortieralgorithen erstmal gleich.
Einen Unterschied gibt es nur beim Tempo, der Anzahl der Vergleiche, der Anzahl der Verschiebungen/Tauschungen und ob das Sortieren "gleicher" Werte stabil ist.

stabil = gleiche Werte bleiben in gleicher Reihenfolge.
-> Frank mit 10 Punkten war vor Thomas mit 10 Punkten und ist es nach dem Sortieren immernoch
Und nur auf dieses "stabil" bezog sich das "nahezu",

Wie dein Vergleich arbeitet, das musst du definieren und auch "richtig" implementieren
und schon funktioniert es auch.

[hoika]

Hallo,

Delphi-Quellcode:

for i:=0 to high(numbers)-1 do
begin
  for k:=i+1 to high(numbers) do
  begin
    if numbers[i]>numbers[k] then
    // Tausche

Um noch mal auf die Grundfrage zu kommen.

Bau dir doch mal ein paar Beispiel numbers Arrays und teste deinen Sortieralgorithmus.

Also: Unit-Test

[EWeiss]

Zitat:

Wie dein Vergleich arbeitet, das musst du definieren und auch "richtig" implementieren

Nach meinem Verständnis ist es richtig implementiert.
Siehe den Codeabschnitt.

Ich sehe kein Kriterium im Quelltext der dem widerspricht.

gruss

[TiGü]

Zitat:

Zitat von EWeiss (Beitrag 1395570)

Zitat:

Wie dein Vergleich arbeitet, das musst du definieren und auch "richtig" implementieren

Nach meinem Verständnis ist es richtig implementiert.
Siehe den Codeabschnitt.

Ich sehe kein Kriterium im Quelltext der dem widerspricht.

gruss

Hast du denn mal die Variablen Angle, AnglePi und zorder[K] geloggt?

[himitsu]

Zitat:

Zitat von EWeiss (Beitrag 1395570)

Zitat:

Wie dein Vergleich arbeitet, das musst du definieren und auch "richtig" implementieren

Siehe den Codeabschnitt.

Welchen?

Antwort #6 ... joar, stimmt soweit.

Delphi-Quellcode:

for i := 0 to High(numbers)-1 do
  for k := i+1 to High(numbers) do
    if numbers[i] > numbers[k] then
      Tausche(i, k)

Das

Delphi-Quellcode:

if ... then

musst du natürlich noch richtig implementieren, denn was man hier aus dem Wirrwarr rauslesen kann, ist dein Vergleich ein scheinbar bissl "anders".



Die Generics gibt es schon seit 2009 und 2010 ging es dann "besser".
k.A. ob Generics.Collections.TArray.Sort bei dir schon verfügbar ist.
fand es nicht, aber in der Hilfe fehlte damals auch noch Vieles http://docwiki.embarcadero.com/RADSt...ulltext=Search
Aber auch hier, musst du den Vergleich anpassen.

[EWeiss]

Zitat:

Zitat von TiGü (Beitrag 1395571)

Zitat:

Zitat von EWeiss (Beitrag 1395570)

Zitat:

Wie dein Vergleich arbeitet, das musst du definieren und auch "richtig" implementieren

Nach meinem Verständnis ist es richtig implementiert.
Siehe den Codeabschnitt.

Ich sehe kein Kriterium im Quelltext der dem widerspricht.

gruss

Hast du denn mal die Variablen Angle, AnglePi und zorder[K] geloggt?

Nein.
Was mit jetzt ein Log da bringen würde entschließt sich mir.
Aber wie gesagt bin bereit jemanden das Projekt zu schocken damit er es mal testen kann.
Was nicht bedeuten soll das er meine Arbeit tun soll ;)

gruss