array sortieren!!!?

[AlexanderBrade]

Hallo, ich habe folgendes Problem:
Ich habe ein array of byte(dynamisch) der Variable B zugeordnet.
Durch setlength(24) habe ich die Variablen B[0], B[1],...B[23] gebildet und diesen Werte zugeordnet.
Dieses Feld habe ich dann sortiert,um die 5 größten Zahlenwerte(1-15) zu bestimmen mit denen ich dann weiterrechne. Bis hierhin klappt alles!
Nun ist es allerdings notwendig von B[0], B[6], B[12] ud B[18] die zwei größten Werte aus dieser Sortierung auszuschließen, da ich mit diesen extern weiterrechne. Die beiden kleineren Werte sollen in der Sortierung allerdings berücksichtigt werden.
Wie kann ich das realisieren, ich hab schon versucht mit einem zweiten array-Feld die 4 Eingaben zu sortieren, allerdings habe ich dann die zwei größten Werte noch lange nicht aus der "anderen" Sortierung ausgeschlossen!

Benötige dringend Hilfe! Bei Fragen wendet euch bitte an mich!

[Klaus01]

Hallo Alexander,

ich würde die zwei größten Werte aus B[0], B[6], B[12] ud B[18] suchen
und diese Indizes dann aus dem großen Array entfernen - oder auf einen Minimalwert setzen.

Grüße
Klaus

[AlexanderBrade]

und wie suche ich nun die zwei größten werte? ich kann ja dafür nicht extra nen Sortieralgorithmu schreiben!
v.a. wenn ich sortiere werden doch die Feldelemente vertauscht(das größe als erstes, usw.), ich weiß doch dann nicht mehr was B[6] oder B[12] ursprünglich war, oder?

[Klaus01]

Zitat:

Zitat von AlexanderBrade

und wie suche ich nun die zwei größten werte? ich kann ja dafür nicht extra nen Sortieralgorithmu schreiben!
v.a. wenn ich sortiere werden doch die Feldelemente vertauscht(das größe als erstes, usw.), ich weiß doch dann nicht mehr was B[6] oder B[12] ursprünglich war, oder?

.. doch Du kannst anhand der Werte den Index des Ursprungselementes ermitteln.
Im einfachsten Fall die 4 Werte durchsuchen wenn ein Wert gefunden wurde Index merken.

Grüße
Klaus

[AlexanderBrade]

Aber wie soll ich die vier Elemente nun sortieren?!? Gibt es für 4 Elemente eine günstigere Variante als einen Sortieralgorithmus?(das größe oder kleinste Element findet man ja leicht, nicht aber das zweitgrößte/zweitkleinste)
P.S. Wie ermittle ich anhand des Wertes den Ursprungindex?

[Klaus01]

.. mache Dir ein Array fülle es mit den Werten von b[0] etc.
Sortiere das Array mit einem Sortieralgorythmus Deiner Wahl (bubbleSort)

Angenommen im sortierten Array a (index von 0..3) steht nun der maximale Wert an letzter Stelle,
das wäre a[3] der zweithöchste steht dann auf a[2].

Delphi-Quellcode:

for i:=2 to 3 do
  case a[i] of
    b[0] : ..
    b[6] : ..
    b[12]: ..
    b[18]: ..
  end;

Grüße
Klaus

[AlexanderBrade]

Was ist a? Das Problem ist, dass ich dann den zweiten BubbleSort Algorithmus einbauen würde!
Den ersten hab ich als

Delphi-Quellcode:

Procedure TForm5.BubbleSort(var B: Array of byte);

geschrieben!
Ich müsste ja nun eine zweite Prozedur schreiben?!? v.a. wie kann ich nur bestimmte Elemente des arrays für die Sortierung vorsehen?

[ghost007]

Hi,
also ich will es dir ja nicht zu einfach machen, aber auf der page hier http://www.algorithm-code.com/wiki/Bubble_sort gibt es zu jedem sortier algo für nahezujede sprache den entsprechenden code. Oben rechts bei related content kannst du auch andere algos anschaun.

MfG - Ghost007

//Edit: Du warst mit deinem letzten post schneller :P

[jfheins]

Zitat:

Zitat von AlexanderBrade

...
Ich müsste ja nun eine zweite Prozedur schreiben?!? v.a. wie kann ich nur bestimmte Elemente des arrays für die Sortierung vorsehen?

Du könntest statt bytes einfach records sortieren, die ein Byte-Feld als Daten haben und ein Boolean-Feld, das angibt, ob dieser Datensatz berücksichtigt werden soll.

Wenn du Bubblesort verwendest, musst du aber schauen, dass du diese Elemente dann überspringst ;)

[AlexanderBrade]

Könnte jemand mal bitte auf meine Frage antworten?!?
Ich möchte folgendes tun: ich will meine Feldvariablen B[0], B[6], B[12] und B[18] sortieren(nicht das ganze array-Feld)!
Dann will ich die zwei größten Elemente, z.B. B[0] und B[12] aus dem dynamischen array(es gibt von B[0] bis B[23])ausschließen bevor ich dieses dann sortiere!(das klappt bereits, aber ohne den Ausschluss der zwei größten Elemente!)
Wie lässt sich dies möglichst unkompliziert hinbekommen?

[angos]

Zitat:

Zitat von AlexanderBrade

Könnte jemand mal bitte auf meine Frage antworten?!?

nicht gleich pampig werden. Aufgrund deiner Fragestellung würde ich sagen, hast du schon Lösungsansätze und Antworten auf deine Frage bekommen.
Da das aber für dich nicht der Fall zu sein scheint, würde ich vorschlagen, dass du deine Frage nochmal genauer formulierst und mit dem schon von dir vorhanden Quellcode untermauerst.
Ich weis jetzt auch nicht mehr was du wirklich willst.

Gruß

[guidok]

Du könntest z.B. folgendes machen:

Delphi-Quellcode:

type

 THilfsArray = record
   Index: Integer;
   Wert: Byte; 
 end;

 HilfsArray = Array [0..3] of THilfsArray;

Jetzt hast du ein Array mit vier Elementen, in das du deine vier zu sortierenden Werte (inklusive des Ursprungsindex) eintragen kannst.

Delphi-Quellcode:

HilfsArray[0].Index := 0;
HilfsArray[0].Wert := B[0];

Jetzt rufst du dein Bubblesort auf und sortierts damit das HilfsArray nach HilfsArray.Wert. Jetzt kennst du die beiden größten Werte und auch den dazugehörigen Index im Array B. Hier musst du die beiden Werte nur noch entfernen.

Das ist sicher nicht der intelligenteste Weg, aber es wäre eine Möglichkeit.

[AlexanderBrade]

Muss ich dann einen "zweiten" BubbleSort-Algorithmu schreiben, denn mein bereits vorhandener bezieht sich ja nur speziell auf mein großen array-Feld?

[taaktaak]

Im Prinzip nicht!
Kommt auf die Implementation der Sortierprozedur an.
Wenn du dieser das Array übergibts, kannst du sie natürlich auch für andere Arrays verwenden.

[AlexanderBrade]

Naja, das mit dem array übergeben haut nicht hin, ich bin eigentlich auch froh, dass er mein großes Feld sortiert! Gibt es nicht noch eine andere Variante zu sortieren, da es ja nur 4 Elemente sind und nur die 2 größten gefunden werden müssen?

[DeddyH]

Seid mir nicht böse, aber ich gewinne den Eindruck, dass hier vielleicht ein Denkfehler im Konzept vorliegt, der nun mit Biegen und Brechen durch aufwändigen Code kompensiert werden soll.
@TE: Erklär doch bitte mal die genaue Aufgabenstellung/Zielsetzung, evtl. geht das auch einfacher.

[jfheins]

Zitat:

Gibt es nicht noch eine andere Variante zu sortieren, da es ja nur 4 Elemente sind und nur die 2 größten gefunden werden müssen?

Warum? SWortieren ist doch nicht so schwer und erfüllt den Zweck. Man könnte jetzt auch irgendwelche Min()/Max() Konstrukte ineinanderschachteln, aber die wären nur unübersichtlich und würden evtl. nicht 100%ig funktionieren...

Zitat:

Zitat von AlexanderBrade

Muss ich dann einen "zweiten" BubbleSort-Algorithmu schreiben

Zitat:

Zitat von AlexanderBrade

ich bin eigentlich auch froh, dass er mein großes Feld sortiert!

Hmmm ... was ist so schwer am Bubblesort? Eigentlich ist er einer der einfachsten (wenn auch nicht effizientesten) Algorithmen. Einfach 2 Schleifen, eine Swap-Funktion und eine if-Anweisung - einfacher gehts doch nicht :gruebel:

[AlexanderBrade]

Also die genaune Zielstellung!
Ich habe 24 editboxen, in die Werte(min. 1 bis max. 15) eingetragen werden können.
Die Aufgabe besteht darin diese Werte einzulesen(in das array-Feld mit der Variable B). Das funktionier durch mein dynamisches array of byte. Durch setlength(23) habe ich definiert, dass B[0] die erste Zuordnung bedeutet und B[23] dem Wert der letzten editbox entspricht!
Nun soll mit dem Feld gearbeitet werden!
Die grundsätzliche Aufgabenstellung besteht darin das Feld zu sortieren um anschließend die 5 größten Werte auszulesen und zu addieren! Bis hierhin funktioniert alles!

Nun sollen allerdings nicht kompromisslos die 5 größten Werte ausgegeben werden, d.h. in diesem Fall ist es notwendig aus der ersten "Spalte"(B[0], B[6], B[12], B[18]) die zwei größten Werte zu ermitteln, da diese immer in die Berechnung einfließen sollen. Das heißt der Sortieralgorithmus sucht dann nur noch die "restlichen" 3 größten Werte. Nun kann allerdings B[0] und B[6] bzw. jegliche andere Kombination die größten Werte beeinhalten, diese Werte müssen dann vor dem Sortieren des "Restfeldes" augeschlossen werden, damit sie herausfallen. Wenn B[0] und B[6] diese beeinhalten dürfen B[12] und B[18] aber nicht ausgeschlossen werden, da auch diese Werte berücksichtigt werden müssen.

Der zweite Teil bereitet mir große Probleme...
Bei Fragen bitte schreiben! Gibt es Verständnisprobleme?!?
Alexander.

[Uwe Raabe]

1) vertausche vor dem ersten Sortieren folgende Array-Werte: B[1] <-> B[6], B[2] <> B[12], B[3] <> B[18]

2) sortiere nun die ersten vier Array-Werte B[0]..B[3] (der größte soll in B[0] stehen)

3) sortiere dann die letzten 21 Array-Werte B[2]..B[23] (der größte soll in B[2] stehen)

Nun hast die in B[0]..B[4] die gewünschten Werte stehen.

[Cyf]

Und benutzt bei SetLength 24, wenn du 24 Werte hast.

[guidok]

Zitat:

Zitat von Uwe Raabe

1) vertausche vor dem ersten Sortieren folgende Array-Werte: B[1] <-> B[6], B[2] <> B[12], B[3] <> B[18]

2) sortiere nun die ersten vier Array-Werte B[0]..B[3] (der größte soll in B[0] stehen)

3) sortiere dann die letzten 21 Array-Werte B[2]..B[23] (der größte soll in B[2] stehen)

Nun hast die in B[0]..B[4] die gewünschten Werte stehen.

Und 1. könntest du dir sparen, wenn du die Werte von 0, 6, 12 und 18 bereits beim Einlesen in das Array an die ersten Positionen setzt und anschließend alle anderen Werte...

[AlexanderBrade]

Wie aber sortier man nun lediglich einen bestimmten Teil des Feldes? z.B. von B[0] bis B[3]?
Wie muss dabei der BubbleSort aufgebaut sein?

[mkinzler]

Die Grenzen ensprechend setzen. Bei diesem Beispiel wäre eine festgecodede Sortierung natürlich sinnvoller

[QuickAndDirty]

Lehrer denken sich schon lustige Dinge aus. Ich frage mich wie die Aufgabenstellung dazu aussah...

[Klaus01]

Ich würde es so lösen:

Deine zulässigen Werte sind 1..15.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  a,b : TByteArray;
  i,j: Integer;
begin
  randomize;
  setLength(b,24);
  for i:=0 to high(b) do
    b[i]:=random(15)+1;
  memo1.lines.add('Ausgabe Array b');
  ausgabe(b);
  setLength(a,4);
  // Übertragung von b[0],b[6],b[12] und b[18] in das Array a
  for i:=0 to high(a) do
   a[i] := b[i*6];

  memo1.lines.add('Ausgabe Array a');
  ausgabe(a);

  bubbleSort(a);

  memo1.lines.add('Ausgabe Array a nach der Sortierung');
  ausgabe(a);
  // zweihhöchster und höchster Wert aus a
  for i:=2 to 3 do
    begin
      for j:=0 to 3 do
        if a[i] = b[j*6] then
          b[j*6] := 0;  // warum 0, weil 0 ein nicht zulässiger Wert ist.
    end;
  memo1.Lines.add('Ausgabe Array b nach der Ersetzung der zwei höchsten Werte aus Array A');
  ausgabe(b);
  bubbleSort(b);
  memo1.Lines.add('Ausgabe Array b nach der Sortierung');
  ausgabe(b);
end;

wobei TByteArray so ausschaut

Delphi-Quellcode:

:
type
  TByteArray = Array of Byte;

und die Signatur von bubbleSort so:

Delphi-Quellcode:

procedure TForm1.bubbleSort(data:TByteArray);

Hier ein Beispieldurchlauf:

Code:

Ausgabe Array b
  5 12  3 10  5  2  8 13 12 12 13  9  2  8  9 12 12 14  1  5  6  5  1  1
Ausgabe Array a
  5  8  2  1
Ausgabe Array a nach der Sortierung
  1  2  5  8
Ausgabe Array b nach der Ersetzung der zwei höchsten Werte aus Array A
  0 12  3 10  5  2  0 13 12 12 13  9  2  8  9 12 12 14  1  5  6  5  1  1
Ausgabe Array b nach der Sortierung
  0  0  1  1  1  2  2  3  5  5  5  6  8  9  9 10 12 12 12 12 12 13 13 14

Grüße
Klaus