Array sortieren, prüfen, zusammenfügen

[M4veR1ck]

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]

Hallo,

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

Grüße

 

[M4veR1ck]

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]

Moin,

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]

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]

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]

... 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]

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]

@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ô]

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ô