Sotieralgorithmus

[fornicator]

Hallo zusammen,
zur Zeit probiere ich gerade einen Sotieralgorithmus zu programmieren der ein Feld von Zahlen der Größe nach anordnet.

Hier der Programmcode den ich bis jetzt habe:

public class test {

public static void main(String[]args){
	int[] B = new int[6];         // das Feld das zum "verschieben" gedacht ist
	int[] A = new int[6];         // das Feld das sotiert werden soll
	              	A[0]=31;
	              	A[1]=41;
	              	A[2]=59;
	              	A[3]=26;
	                A[4]=43;
	                A[5]=58;
	                
for(int i=1;i<6;i++){      // hier wird das Feld der zu sotierende Zahlen durchgegangen
  for(int a=0;a<i;a++)    // hier soll der aktuelle Wert mit den bisherigen Werten verglichen
   {                                // werden
     if (A[i]<A[a]){                                      // falls der aktuelle Wert kleiner ist als eines der bereits
    	 for(int x=a;x<i;x++){A[x]=B[x];}    // sotierten Werten wird die Schleife angehalten alle 
    	 A[a]=A[i];                                        // Werte in dem Feld B gespeichert die gößer sind als  
    	 for(int y=a;y<i;y++){A[y+1]=B[y];}  // der aktuelle Wert,der aktuelle Wert wird eingefügt
    	 break;                                               // und der Rest eins nach rechts verschoben
     }
   }
}
for(int c=0;c<6;c++){                         // Hier wird die Ausgabe des 
	  System.out.print(A[c]+"\t");}     // sotierten Feldes erzeugt.
}
}

Aber der Algorithmus funktioniert aber nicht richtig. Weil er folgende Ausgabe produziert:
26 0 0 0 43 58 was offensichtlich falsch ist.
Sieht jemand den Fehler den ich gemacht habe? - Habe probiert den Code so zu kommentieren das klar wird was ich mir gedacht , falls ich was nicht oder echt schlecht kommentiert habe bitte nachfragen.

 

[nillehammer]

Gegen den Algorithmus an sich ist nichts einzuwenden. Ich denke aber, man sollte den Code umschreiben, dass er lesbarer wird. Versuch mal, die verschachtelten for-Schleifen von innen nach außen in Methoden mit entsprechenden Namen, Parametern und Rückgabe werten zu refactorn. Dann bin ich sicher, dass Du den Fehler selbst finden wirst.

 

[Marcinek]

Naja in B ist alle 0.

und bei deiner ersten if machst du Ax = Bx

Boom

 

[fornicator]

Danke für den Hinweis, werd ich gleich ma machen(war echt etwas unübersichtlich) - werds dan im Laufe vom Abend oder morgen mein Ergbnis hochladen

 

[Final_Striker]

Also ich weiß nicht welcher Sortieralgorithmus das sein soll, aber einer der langsamsten (Bubblesort) hat 2 verschachtelte for-Schleifen.
Die zwei innere for-Schleifen braucht du genauso wenig wie das

B

Array.

Zwei Werte tauschen:

   if (A[0]>A[1]){
      int temp = A[0];
      A[0] = A[1];
      A[1] = temp;
   }

 

[fornicator]

Erst mal danke für alle die Antworten

Marcinek du hattest recht die Zuweisung war falsch herum - es musste B[x]=A[x] und nicht A[x]=B[x]. Hab das vertauscht und dan hat es super geklappt - hab danach auch noch die einzelnen Sachen in Methoden ausgelagert so wie es nillehammer wollte - war auch noma eine gute Übung zu den Methoden erstellen und aufrufen.

@Final_Striker - hab probiert mal den Sotieren durch Einfügen Algorithmus selber zu schreiben. Der Bubbelsort Code ist aber wirklich übersichtlicher als meiner. - Bin noch nicht soweit das ich Algorithmen selber bewerten kann, aber würde gerne wissen wie gut mein Versuch war (vor allem hinsichtlich der Laufzeit) - hoffe ihr könnt mir da weiter helfen

 

[chalkbag]

Der Nachteil von deinem Sortieralgorithmus ist, dass er nicht "inplace" ist. D.h. du speicherst Daten zwischen und hällst so zwei Listen im Speicher was vor allem bei großen Datenmengen problematisch ist. Von der Komplexität würde ich eine starke Ähnlichkeit zum bubblesort vermuten (möge mich das große O erschlagen, wenn ich hier falsch liege).
An sich finde ich es auch eher sinnvoll, einen Sortieralgorithmus sich nicht selber irgendwie zu überlegen, sondern bereits erprobte und somit auch laufzeittechnisch einschätzbare Algorithmen zu verwenden. Als gute Durchschnittslösung wäre hier wohl der Quicksort zu empfehlen.

Natürlich ist es aber schön das dein Algorithmus nun funktioniert und sicherlich hast du dabei auch etwas gelernt, was ja auch schon was Tolles ist. :applaus:

 

[fornicator]

Ok, dan werd ich mich den Sotieralgorithmus den mein Buch vorschlägt absofort werden.

 

[Final_Striker]

Bin noch nicht soweit das ich Algorithmen selber bewerten kann, aber würde gerne wissen wie gut mein Versuch war (vor allem hinsichtlich der Laufzeit) - hoffe ihr könnt mir da weiter helfen

Du hast 3 verschachtelte for-Schleifen, damit quasi grob ein Komplexität von O(n³). Also unterirdisch langsam. ;-)

 

[fornicator]

Ok - dan doch eindeutig den Code aus dem Buch^^
Dan bedank ich mich bei allen für ihre Antworten und markiere mal das Thema als erledigt.