Hallo,

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

public class Sort1 {      public static void main (String args[])  {   int [][] wert = {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};   int [] sort ;   sort = new int[16];         for (int i = 0; i < wert.length; i++)   {       for (int j = 0; j < wert.length; j++)       {       //System.out.println(wert[i]);       sort[0] = wert[0][0];     //  <== Hier habe ich ein Problem und zwar müßte ich den Wert jeweil um 1 erhöhen                                             //          oder muß ich Hier von Dimension zu Dimension vorgehen?           java.util.Arrays.sort( sort );       }   }       for (int j = 0; j < sort.length; j++)   {     System.out.println(sort); } } }

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

public class Sort1 {     public static void main (String args[])     {         int [][] wert = {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};         int [] sort ;         sort = new int[16];           for (int i = 0, k = 0; i < wert.length; i++)         {             for (int j = 0; j < wert.length; j++, k++)             {                 sort[k] = wert[j][i];             }         }         java.util.Arrays.sort( sort );         for (int j = 0; j < sort.length; j++)         {             System.out.println(sort);         }     } }

Ich versuche es einfach mal so ohne zu testen ect, aber nachdem du nicht wirklich eine Frage gestellt hast und dich nicht an die einfachsten Formationsregeln gehalten hast kannst du mehr auch nicht erwarten.

Was ich mich frage ist, warum sich jemand die Mühe macht ein 2D-Array zu nutzen, wenn er am Ende bloß alles in einer Dimension braucht.

Hallo,

du solltest eigentlich lange genug hier angemeldet sein, um zu wissen, dass man Quelltext in die Code-Tags packt.

Wie möchtest du denn das 2D-Array in sort packen?
Spalten oder Zeilenweise?


Warum rufst du bei jedem einfügen Arrays.sort auf?

Gruß

Sascha

Hallo, ich möchte das Array sortieren und dann die Häufigkeit der einzelenen Werte ermitteln(Histogramm) da war meine
Idee mit dem überführen in das eindimensionale Array und dann die Sortierung. Anschließend kann ich die Werte mit einer
Zählschleife durchlaufen und die Häufigkeit ermitteln?

Mein Ergebnis in BlueJ ist allerdings


[ Sort1.main({ }) ]
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc
[I@848ecc

Scheint das ich da noch ein Problem mit dem Ergebnis habe?

Warum? Du hast ihm angewiesen, das er n mal die toString()-Methode des Arrays ausgibst, und genau das tut er. Wenn du ihm ein Feld für die Ausgabe sagen würdest wäre das natürlich was anderes...

Probiers mal mit:

Code java:

1	System.out.println(java.util.Arrays.toString(sort));

Hi FiselM,
das sollte funktionieren:

Code java:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

import java.util.ArrayList; import java.util.Arrays;   public class test{         public static void main (String args[])       {           int [][] wert = {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17},{34,34,127,17}};             ArrayList<Integer> sortList = new ArrayList<Integer>();         for (int i = 0; i < wert.length; i++)           {                   for (int j = 0; j < wert[0].length; j++)                   {                   //System.out.println(wert[i]);                       sortList.add(wert[i][j]);                 }           }         int [] sort = new int[sortList.size()];         for (int i = 0; i < sort.length; i++) {             sort[i] = sortList.get(i);         }         Arrays.sort(sort);         int temp = sort[0];         int zaehler = 1;         for (int i = 1; i < sort.length; i++) {             if(temp != sort[i])             {                 System.out.println("Die Zahl "+ String.valueOf(temp)+" ist im zweidimensionalen Array genau " + String.valueOf(zaehler)+ " enthalten!");                 temp = sort[i];                 zaehler = 1;             }             else             {                 zaehler++;             }         }         System.out.println("Die Zahl "+ String.valueOf(temp)+" ist im zweidimensionalen Array genau " + String.valueOf(zaehler)+ " enthalten!");     } }

Gruß
Anton

Mein Problem in dem Programm ist, dass ich nach der Erzeugung eines neuen sortierten Arrays
die Anzahl der gleichen Werte ermitteln möchte (Histogramm) Ich schaffe den ersten Wert mit 11 Anzahl 1.
Aber dann steigt mein Programm aus, und kerht nicht mehr zur Vorbedingung zurück? Kann mir jemand helfen?

PS wie erzeugt man nochmals die Tags?

Code :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

/**  * Beschreiben Sie hier die Klasse Sort1.  *  * @author (Ihr Name)  * @version (eine Versionsnummer oder ein Datum)  */   import java.util.*; public class Sort2 {       public static void main (String args[])     {         int [][] wert = {{34,255,255,56},{127,204,11,34},{123,98,127,34},{34,34,127,17}};         int [] sort ;         sort = new int[16];           for (int i = 0, k = 0; i < wert.length; i++)         {             for (int j = 0  ; j < wert.length; j++, k++)             {                                 sort[k] = wert[j][i];                         }                 }                 java.util.Arrays.sort( sort );         // Histogramm Durchlauf des Arrays sort         // ermitteln der doppelten Einträge, addieren eines Zählers und Ausgabe.         System.out.println(sort);         for (int k = 0 ; k < sort.length ; k++ )         {               int test = 0;             test = sort.length+1;             int anzahl = 0;             do             {                 anzahl = anzahl + 1;               }             while  (sort[k] == test);               System.out.println(sort[k]);             System.out.println(anzahl);         }     } }