Elemente in Arrays verschieben

Diskutiere Elemente in Arrays verschieben im Hausaufgaben Bereich.
S

Sabine.Quast

Hallo,

ich habe ein Array Typ Klasse.

Klasse [] Array = new Klasse;

Die Elemente des Arrays sind Attribute einer anderen Klasse.
durch gezieltes löschen wurden manche Elemente dieses Arrays zu Nullstellen.
Jetzt will ich eine Methode Schreiben die das Array so sortiert das alle Nullstellen ganz hinten stehen sollen.
Im Internet finde ich nichts vergleichbares.

Ich bedanke mich im voraus für jeden Hinweis.


Lg, Sabine
 
J

JennyL

Meinste das?
Java:
		String[] a = {
				"a",
				null,
				"b",
				null,
				null,
				"c"
			};
		Arrays.sort(a, new Comparator<String>() {
			@Override
			public int compare(String o1, String o2) {
				int i = o1 == null ? 1 : 0 - (o2 == null ? 1 : 0);
				return i;
			}
		});
		System.out.println(Arrays.toString(a));
 
S

Sabine.Quast

Meinste das?
Java:
        String[] a = {
                "a",
                null,
                "b",
                null,
                null,
                "c"
            };
        Arrays.sort(a, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int i = o1 == null ? 1 : 0 - (o2 == null ? 1 : 0);
                return i;
            }
        });
        System.out.println(Arrays.toString(a));

Der Array muss schon typ Klasse sein.
Person[] Mensch = new Person[5].
mit for schleife menschen bilden....
Menschen wurde der Wert Null gegeben.
z.b

Mensch[0] = irgentwas;
Mensch[1] = Null;
Mensch[2] = irgentwas;
Mensch[3] = Null;
Mensch[4] = irgentwas;

daraufhin soll der Array mit einer Methode sortiert werden das er das wiedergibt:
Mensch[0] = irgentwas;
Mensch[2] = irgentwas;
Mensch[4] = irgentwas;
Mensch[1] = Null;
Mensch[3] = Null;

am besten mit einer for-Schleife wenn möglich.
 
J

JennyL

Sortieren ist schneller als jedes Element nach hinten verschieben:
Java:
		String[] a = {
				"a",
				null,
				"b",
				null,
				null,
				"c"
			};
		Arrays.sort(a, new Comparator() {
			@Override
			public int compare(Object o1, Object o2) {
				int i = o1 == null ? 1 : 0 - (o2 == null ? 1 : 0);
				return i;
			}
		});
		System.out.println(Arrays.toString(a));
 
S

Sabine.Quast

Sortieren ist schneller als jedes Element nach hinten verschieben:
Java:
        String[] a = {
                "a",
                null,
                "b",
                null,
                null,
                "c"
            };
        Arrays.sort(a, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                int i = o1 == null ? 1 : 0 - (o2 == null ? 1 : 0);
                return i;
            }
        });
        System.out.println(Arrays.toString(a));
mein Array ist nicht von Typ String
 
L

LimDul

mein Array ist nicht von Typ String
Dann transferie die Lösung auf dein Problem und nimm deinen Datentyp.

Sortieren ist schneller als jedes Element nach hinten verschieben:
Unfug. Sortieren hat eine Laufzeit von O(n log n), die Aufgabenstellung bekommt man auch in O(n) hin, wenn ich jedes Element nur nach hinten schiebe. Laufzeitechnisch ist nach hinten verschieben schneller als sortieren.
 
S

Sabine.Quast

Dann transferie die Lösung auf dein Problem und nimm deinen Datentyp.


Unfug. Sortieren hat eine Laufzeit von O(n log n), die Aufgabenstellung bekommt man auch in O(n) hin, wenn ich jedes Element nur nach hinten schiebe. Laufzeitechnisch ist nach hinten verschieben schneller als sortieren.

hat erst jetzt geklappt.
kann man das auch anfängertauglicher machen, sprich mit Schleifen?
 
MoxxiManagarm

MoxxiManagarm

kann man das auch anfängertauglicher machen, sprich mit Schleifen?
Ich hätte eine rekursive Variante

Java:
public static String[] move(String[] array, int x) {
    if (x == array.length) return new String[0];

    String[] result = new String[array.length - x];
    String[] rekursiv = move(array, x + 1);

    int offset = array[x] == null ? 0 : 1;
    result[0] = array[x];

    for (int i = 0; i < rekursiv.length; i++) {
        result[i + offset] = rekursiv[i];
    }

    return result;
}

public static void main(String[] args) {
    String[] array = {null, "1", null, null, "2", "3", "4", "5", null, "6", "7", "8", "9", null, null, "10", null, "11", "12", "13"};

    System.out.println("In: " + Arrays.toString(array));
    array = move(array, 0);
    System.out.println("Out: " + Arrays.toString(array));
}
Ausgabe:
Code:
In: [null, 1, null, null, 2, 3, 4, 5, null, 6, 7, 8, 9, null, null, 10, null, 11, 12, 13]
Out: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, null, null, null, null, null, null, null]
 
J

JennyL

Unfug. Sortieren hat eine Laufzeit von O(n log n), die Aufgabenstellung bekommt man auch in O(n) hin, wenn ich jedes Element nur nach hinten schiebe. Laufzeitechnisch ist nach hinten verschieben schneller als sortieren.
Du solltest etwas auf deinen Umgangston achten, ansonsten könnte das für dich schnell unangenehm werden. Jedes Element aufzuschieben hat eine Laufzeit von O(n²). Es gilt weiterhin O(n²)>O(n log(n)).
 
MoxxiManagarm

MoxxiManagarm

Und hier noch die einfache iterative Variante, die natürlich am sinnvollsten ist ;-)

Java:
String[] in = {null, "1", null, null, "2", "3", "4", "5", null, "6", "7", "8", "9", null, null, "10", null, "11", "12", "13"};
String[] out = new String[in.length];

System.out.println("In: " + Arrays.toString(in));

int j = 0;
for (int i = 0; i < in.length; i++) {
    if (in[i] != null) {
        out[j++] = in[i];
    }
}

System.out.println("Out: " + Arrays.toString(out));
 
MoxxiManagarm

MoxxiManagarm

@MoxxiManagarm Du erstellst ein zusätzliches Array (Speicherplatzverbrauch 2*n), ich weiß nicht ob das die Aufgabenstellung vorsieht.
Na dann halt so 🤷‍♀️

Java:
String[] array = {null, "1", null, null, "2", "3", "4", "5", null, "6", "7", "8", "9", null, null, "10", null, "11", "12", "13"};
System.out.println("In: " + Arrays.toString(array));

int j = 0;
for (int i = 0; i < array.length; i++) {
    if (array[i] != null) {
        array[j++] = array[i];
        array[i] = null;
    }
}

System.out.println("Out: " + Arrays.toString(array));
 
L

LimDul

Du solltest etwas auf deinen Umgangston achten, ansonsten könnte das für dich schnell unangenehm werden. Jedes Element aufzuschieben hat eine Laufzeit von O(n²). Es gilt weiterhin O(n²)>O(n log(n)).
Nö. ich muss nur tauschen, ich muss jedes Element 1x anfassen.
 
J

JennyL

@MoxxiManagarm
Java:
		String[] array = { "1", null, null, null, null };
		System.out.println("In: " + Arrays.toString(array));

		int j = 0;
		for (int i = 0; i < array.length; i++) {
			if (array[i] != null) {
				array[j++] = array[i];
				array[i] = null;
			}
		}

		System.out.println("Out: " + Arrays.toString(array));
@LimDul Die Operation "ein Element nach hinten zu verschieben" erfordert alle Elemente aufzuschieben. Aber ich lasse mich natürlich gerne vom Gegenteil überraschen.
 
L

LimDul

Verschieben nicht von "ich lasse es wie in einem bubblesort aufsteigen" sondern ich tausche es direkt nach hinten.
 
J

JennyL

Ja aber du weißt ja nicht, wohin.

Edit: Bzw, du weißt schon wohin, aber du kannst nicht einfach vertauschen, du musst "aufschieben".
 
Zuletzt bearbeitet:
J

JennyL

Vielleicht noch ein Beispiel:
Java:
	public static void moveNullToBack(Object[] a) {
		int x = a.length - 1;
		for (int i = 0; i < x; i++) {
			if (a[i] == null) {
				Object o = a[x];
				a[x] = a[i];
				a[i] = o;
			}
		}
	}
Das würde funktionieren, wenn wir ausschließen könnten, dass hinten nicht bereits null-Elemente stehen. Da wir das aber nicht ausschließen können, "müssen" wir nach hinten verschieben. Das Verschieben kostet eine weitere innere Schleife, dadurch erhöht sich dann die Komplexität auf n².
 
L

LimDul

Java:
public class ArrayTest {

    private static String[] strings = { "a", "b", null, "c", null, null, "d" };

    public static void main(String[] args) {

        int i = 0;
        int j = strings.length - 1;

        while (i < j) {
            if (strings[i] == null && strings[j] != null) {
                strings[i] = strings[j];
                strings[j] = null;
            }
            if (strings[i] != null) {
                i++;
            }
            if (strings[j] == null) {
                j--;
            }
        }

        System.out.println(Arrays.toString(strings));
    }

}
Laufzeit O(n).
 
Thema: 

Elemente in Arrays verschieben

Passende Stellenanzeigen aus deiner Region:
Anzeige

Neue Themen

Anzeige

Anzeige
Oben