# Array sortieren, prüfen, zusammenfügen



## M4veR1ck (31. Mai 2010)

Morgen,

Ich hab die sufu schon benutzt und versucht ein Thread zu meinen Problem zu finden... Doch Ich war nicht erfolgreich... Also falls es einen solchen Thread schon gibt... Pls Link.

Nun zu meiner Problemstellung..... Ich habe 2 Arrays mit double Zahlen. Beide besitzen eine Unterschiedliche Länge und auch gleiche Zahlen. Ich muss sie ohne halt zu zählen etc. sie in ein anderes Array eintragen, sortieren und darauf achten das jede Zahl nur 1 mal vorhanden ist. Die Länge des gesuchten Arrays hab ich schon. Ich habe auch versucht es selbst zu ordnen bzw einzutragen aber entweder gab er mir nur 8.0 aus oder eine andere Zahl halt....
Entweder bin ich dazu viel zu blöd oder es ist einfach zu einfach....
Würde mich über Hilfe sehr freuen...

Array1: {1.0,3.0,5.0,6.0,9.0}
Array2: {2.0,3.0,5.0,7.0,8.0,9.0,9.0}

Gruß Mav


----------



## FrankBooth (31. Mai 2010)

Hallo,

sind die beiden Arrays schon sortiert? In deinem Beispiel sind sie es.

Grüße


----------



## M4veR1ck (31. Mai 2010)

Das sind die beiden Arrays... Aber wenn ich es so machen würd wie ich es im Kopf hatte wäre es nicht sortiert....


----------



## vfl_freak (31. Mai 2010)

Moin,



M4veR1ck hat gesagt.:


> Das sind die beiden Arrays... Aber wenn ich es so machen würd wie ich es im Kopf hatte wäre es nicht sortiert....



Bitte was 

Poste mal den Code, den Du hast, vlt. blickt man dann durch ....

Gruß
Klaus


----------



## M4veR1ck (31. Mai 2010)

```
package arrays;

public class Mischen {

	public static void main(String[] args) {

		double[] menge1 = {1.0,3.0,5.0,6.0,9.0};
		double[] menge2 = {2.0,3.0,5.0,7.0,8.0,9.0,9.0};
		int zaehler1 = 0;
		int zaehler2 = 0;
		boolean gleich = false;
		
		while(zaehler1 < menge2.length){
			zaehler1++;
		}

		for(int i = 0; i < menge1.length; i++){
			for(int j = 0; j < menge2.length; j++){
				if(menge1[i] == menge2[j]){
					zaehler2++;
				}
			}
		}

	    double[] mengeGe = new double[menge1.length + (zaehler1 - zaehler2)];
	    
	    for(int i = 0; i < mengeGe.length; i++){
	    	mengeGe[i] = 0;
	    }
	    
	    for(int i = 0; i < mengeGe.length; i++){
	    	for(int j = 0; j < menge1.length; j++){
	    		for(int k = 0; k < menge2.length; k++){
	    			if(mengeGe[i] == 0){
	    				if(menge1[j] < menge2[k]){
	    					mengeGe[i] = menge1[j];
	    				}
	    				else if(menge1[j] < menge2[k]){
	    					mengeGe[i] = menge2[k];
	    				}
	    			}
	    		}
	    	}
	    }
	    
	    for(int i = 0; i < mengeGe.length; i++){
	    	System.out.println(mengeGe[i]);
	    }
	}
}
```


----------



## Artorius (31. Mai 2010)

Hier mal ein kleines Beispiel, wo man nicht viel selbst machen muss.
Dabei ist es egal, ob die Array<s am Anfang sortiert sind oder nicht.

```
Double[] one  = {1.0,2.0,3.0,3.0,4.0,9.0};
       Double[] two  = {1.0,1.5,2.0,3.0,3.0,3.0,4.0,8.5,9.0};
       HashSet<Double> set = new HashSet<Double>();
       set.addAll(Arrays.asList(one));
       set.addAll(Arrays.asList(two));
       Double[] result = set.toArray(new Double[0]);
       Arrays.sort(result);
       for(int i=0; i < result.length; i++)
             System.out.println(result[i]);
```

Ausgabe:

```
1.0
1.5
2.0
3.0
4.0
8.5
9.0
```

*grüssle*


----------



## FrankBooth (31. Mai 2010)

... oder dein Beispiel erweitert/verändert



```
public static void main(String[] args) {
		
		double[] menge1 = {1.0,3.0,5.0,6.0,9.0};
		double[] menge2 = {2.0,3.0,5.0,7.0,8.0,9.0,9.0};
		int zaehler1 = 0;
		int zaehler2 = 0;
		boolean gleich = false;
		
		while(zaehler1 < menge2.length){
			zaehler1++;
		}

		for(int i = 0; i < menge1.length; i++){
			for(int j = 0; j < menge2.length; j++){
				if(menge1[i] == menge2[j]){
					zaehler2++;
				}
			}
		}

		double[] mengeGe = new double[menge1.length + (zaehler1 - zaehler2)];
	    
	    for(int i = 0; i < mengeGe.length; i++){
	    	mengeGe[i] = 0;
	    }

		
		zaehler1 = 0;
		zaehler2 = 0;
		int k = 0;
	
		
		while(zaehler1 < menge1.length && zaehler2 < menge2.length) {
			
			if (menge1[zaehler1] < menge2[zaehler2]) {
				mengeGe[k] = menge1[zaehler1];
				zaehler1++;
				k++;
			} else if (menge1[zaehler1] > menge2[zaehler2]) {
				mengeGe[k] = menge2[zaehler2];
				k++;
				zaehler2++;
			} else {
				if (menge2[zaehler2] != mengeGe[k-1]) {
					mengeGe[k] = menge2[zaehler2];
					zaehler1++;
					zaehler2++;
					k++;
				} else {
					zaehler1++;
					zaehler2++;
				}
			}
				
		}

        if (zaehler1 < menge1.length) {
			if (menge1[zaehler1] != mengeGe[k-1]) {
				mengeGe[k] = menge1[zaehler1];
				zaehler1++;
				k++;
			} else {
				zaehler1++;
			}
		}
			
	    if (zaehler2 < menge2.length) {
			if (menge2[zaehler2] != mengeGe[k-1]) {
				mengeGe[k] = menge2[zaehler2];
				zaehler2++;
				k++;
			} else {
				zaehler2++;
			}
		}
		
		for (double d : mengeGe) {
			System.out.println(d);
		}
		
		
	}
```


----------



## Thomas Darimont (31. Mai 2010)

Hallo,

so gings auch:

```
package de.tutorials;

import java.util.Arrays;
import java.util.SortedSet;
import java.util.TreeSet;

public class UnionArrays {
  public static void main(String[] args) {
    Double[] a = { 1.0, 3.0, 5.0, 6.0, 9.0 };
    Double[] b = { 2.0, 3.0, 5.0, 7.0, 8.0, 9.0, 9.0 };

    SortedSet<Double> sortedUniqueElements = new TreeSet<Double>();
    for (Double[] array : new Double[][] { a, b }) {
      sortedUniqueElements.addAll(Arrays.asList(array));
    }

    Double[] c = sortedUniqueElements.toArray(new Double[0]);
    
    System.out.println(Arrays.toString(c));
  }

}
```

Gruß Tom


----------



## M4veR1ck (31. Mai 2010)

@Artorius
Ist zwar neh super Lösung, die ich mir auch merken werd ;D , aber die ist nicht ganz für meinen Gebrauch geeignet da ich des für die Schule brauch.... Hätt ich vllt auch bei schreiben sollen ;D

@FrankBooth
Danke das ist super! Nur leider funktioniert das nicht mit Komma Zahlen...

@Tom
Deins werd ich mir ebenfalls merken aber wie oben bei Artorius schon gesagt nicht für meinen Gebrauch geeignet ;D

Aber auf jedenfall danke an euch drei!


----------



## rhô (3. Juni 2010)

Hi,

was hältst du davonzuerst die Arrays zu sortieren. Dann ist das Füllen des Ergebnisarrays trivial.
Ich hab da mal was vorbereitet 


```
package abc;

import java.io.PrintWriter;

public class Mischen {
	
	public static void main(String[] args) {

		double[] menge1 = {1.0,3.0,5.0,6.0,9.0};
		double[] menge2 = {2.0,3.0,5.0,7.0,8.0,9.0,9.0};
		
		double[] menge1sorted = goGnome(menge1);
		double[] menge2sorted = goGnome(menge2);
		
		int anzahlDoppelte = 0;
		
		for(int i = 0; i < menge1.length; i++){						//zum zaehlen der redundanten Elemente
			for(int j = 0; j < menge2.length; j++){
				if(menge1[i] == menge2[j]){
					anzahlDoppelte++;
				}
			}
		}
		
		double[] ergebnis = new double[menge1.length + menge2.length - anzahlDoppelte];
		
		int zaehler1 = 0;
		int zaehler2 = 0;
		for(int i = 0; i < ergebnis.length; i++){					//fuellt das Ergebnisarray mit den entsprechenden Werten
			if(menge1sorted[zaehler1] < menge2sorted[zaehler2]){
				ergebnis[i] = menge1[zaehler1];
				zaehler1++;
				continue;
			}
			if(menge1sorted[zaehler1] == menge2sorted[zaehler2]){
				ergebnis[i] = menge1[zaehler1];
				zaehler1++;
				zaehler2++;
				continue;
			}
			if(menge1sorted[zaehler1] > menge2sorted[zaehler2]){
				ergebnis[i] = menge2[zaehler2];
				zaehler2++;
				continue;
			}
		}
		
		arrayOut(ergebnis);
	}
	
	/**implementiert den GnomeSort Algorithmus für Double-Arrays
	 * @param array zu sortierendes Array, wird nicht verändert
	 * @return sortierte Kopie des Arrays
	 */
	public static double[] goGnome(double[] array){
		double[] rry = array.clone();			//Ausgabe-Array
		int index = 0;							//Position im Array
		while(index < rry.length -1){
			if(rry[index] > rry[index+1]){		//bei falscher Reihenfolge:
				swap(rry, index, index+1);
				if(index > 0){					//nicht am linken Rand:
					index--;					//Schritt nach links
					continue;					//naechster Schleifendurchlauf
				}
			}
			index++;							//Schritt nach rechts
		}
		return rry;
	}
	
	/**vertauscht zwei Werte eines Integer-Arrays
	 * @param array Double-Array in dem getauscht wird
	 * @param index0 Index des ersten zu vertauschenden Werts
	 * @param index1 Index des zweiten zu vertauschenden Werts
	 */
	private static void swap(double[] array, int index0, int index1){
		double temp = array[index0];
		array[index0] = array[index1];
		array[index1] = temp;
	}
	
	/**Methode gibt uebergebenes Array in einer Zeile
	 * auf der Standardausgabe aus
	 * 
	 * @param array auszugebenes Array
	 */
	private static void arrayOut(double[] array){
		PrintWriter out = new PrintWriter(System.out, true);
		out.print("[ ");
		for(double item : array){
			out.print(item + " ");
		}
		out.println("]");
	}
}
```

Ich hab es auch getestet und es funktioniert. Der Gnomesort-Algorithmus ist zwar ganz simpel aber für die Schule denke ich sollte es reichen.

Grüße rhô


----------



## M4veR1ck (3. Juni 2010)

@rhô
Ist neh interessante Lösung... Muss ich mir mal genauer angucken aber für die Schule zu ungeeignet... Meine Lehrerin meint halt immer ich soll Sachen benutzen die meine Mitschüler auch "verstehen"... Naja und ich denk für die ist das einfach zu hoch...

Nebenbei, kann mir wer sagen wieso der nur 1.0 aus gibt... und falls wer ne Lösung weiß wie man das erfolgreich umändern kann sodas es funktioniert und nicht zu hoch ist? ^^

```
public class Mischen {

	public static void main(String[] args) {
	       
        double[] menge1 = {1.0,3.0,5.0,6.0,9.0};
        double[] menge2 = {2.0,3.0,5.0,7.0,8.0,9.0,9.0};
        int zaehler1 = 0;
        int zaehler2 = 0;
       
        while(zaehler1 < menge2.length){
            zaehler1++;
        }
 
        for(int i = 0; i < menge1.length; i++){
            for(int j = 0; j < menge2.length; j++){
                if(menge1[i] == menge2[j]){
                    zaehler2++;
                }
            }
        }
 
        double[] mengeGe = new double[menge1.length + (zaehler1 - zaehler2)];
        
        for(int i = 0; i < mengeGe.length; i++){
        	mengeGe[i] = 0;
        }
        
        for(int i = 0; i < mengeGe.length; i++){
        	for(int j = 0; j < menge1.length; j++){
        		if(mengeGe[i] == 0){
        			for(int k = 0; k < menge2.length; k++){
        				if(mengeGe[i] == 0){
        					if(menge1[j] < menge2[k]){
        						mengeGe[i] = menge1[j];
        					}
        					else if(menge1[j] > menge2[k]){
        						mengeGe[i] = menge2[k];
        					}
        				}
        			}
        		}
        	}
        }
        
        for(int i = 0; i < mengeGe.length; i++){
        	System.out.println(mengeGe[i]);
        }
       
	}  
}
```


----------



## rhô (4. Juni 2010)

Hey,
ich hab noch mal in der API nachgeschlagen. Ruf einfach Arrays.sort(menge1); Arrays.sort(menge2); auf und du hast zwei sortierte Arrays ohne GnomeSort.
Danach musst du nur noch einmal durch die Arrays um sie in dein Ergebnisarray zu schreiben wie in meinem Beispiel.

Hier nochmal der Link zur API: http://java.sun.com/javase/6/docs/api/ 
Einfach nach "Arrays" suchen.


----------



## FrankBooth (7. Juni 2010)

M4veR1ck hat gesagt.:


> @FrankBooth
> Danke das ist super! Nur leider funktioniert das nicht mit Komma Zahlen...



Wie jetzt? Äh was geht nicht?


----------



## M4veR1ck (7. Juni 2010)

Ahhh, neh funkt soweit nur sobald ich zahlen die höher sind als 22 eingeb funkts net... vllt irr ich mich auch grad... Eclipse hat da ein bissel rumgesponnen....


----------



## M4veR1ck (7. Juni 2010)

Sobald ich bei deinem Programm zB. 2.20 oder sowas wie 76.0 eingeb funktioniert er net mehr!


----------



## FrankBooth (7. Juni 2010)

Stimmt nicht. Das Problem liegt bei meinem Code nicht an Zahlen wie 2.20 oder 76.0.
Das Problem hat mein Programm mit doppelten Zahlen in einem Array.

Grüße


----------



## M4veR1ck (7. Juni 2010)

Kannste mir das dann nicht einmal das komplett funktionierende Programm posten?


----------



## FrankBooth (8. Juni 2010)

Nein das kann ich natürlich nicht 

Es gibt in der Lösung 2 Probleme:

1. Die Bestimmung der Länge des Ergebnisarrays.
Wenn in deinem 2. Array eine Zahl doppelt vorkommt und sie kommt in deinem ersten Array gar nicht vor, wird sie auch doppelt gezählt


```
double[] menge1 = {2.0,3.4,5.0,7.0,8.0, 10.0};
double[] menge2 = {1.1,3.0,5.0,6.0,9.0,9.0,22.6,76.0,113.0,222.0,222.0,330.0};
```

ergibt in der Zeile 17


```
double[] mengeGe = new double[menge1.length + (zaehler1 - zaehler2)];
System.out.println(menge1.length + (zaehler1 - zaehler2));
```
Es sind aber nur 15 unterschiedliche Werte. Die Werte 9.0 und 220.0 werden doppelt gezählt bzw. nicht als doppelte erkannt (zaehler2++)

In meinem Code gibt es an dieser Stelle Probleme:


```
if (menge1[zaehler1] < menge2[zaehler2]) {
	mengeGe[k] = menge1[zaehler1];
	zaehler1++;
	k++;
} else if (menge1[zaehler1] > menge2[zaehler2]) {
	mengeGe[k] = menge2[zaehler2];
	k++;
	zaehler2++;
```

durch die Doppelten in einem Array muss vor dem Eintragen in mengeGe[k] auch überprüft werden, ob der Vorgänger von mengeGe[k] nicht gleich ist.


```
while (zaehler1 < menge1.length) {
			if (menge1[zaehler1] != mengeGe[k-1]) {
				mengeGe[k] = menge1[zaehler1];
				zaehler1++;
				k++;
			} else {
				zaehler1++;
			}
}
			
while (zaehler2 < menge2.length) {
         if (menge2[zaehler2] != mengeGe[k-1]) {
                 mengeGe[k] = menge2[zaehler2];
                 zaehler2++;
                 k++;
          } else {
                zaehler2++;
          }
}
```
Dazu kommt, das alle übrigen Werte aus dem Größeren Array eingetragen werden müssen. Daher *while* und nicht *if* 
Viel Spaß beim Lösen 

Grüße


----------

