Zeichensortierung im String

[_bella_]

Hallo
ich muss für die Schule folgende Aufgabe lösen und komme nicht auf meinen Fehler:
1)Ermittlung des aktuell kleinsten Zeichens C aus dem String S;
2)Aufbau eines neuen Strings R, an den das Zeichen C angehängt wird (aufsteigende Sortierung);
3)Entfernung von C aus S, wodurch S sukzessive schrumpft.

Hier mein Code:

public static String sort(String s) {
		String r = "";
		char min = ' ';
		while (s != null) {
			for (int i = 1; i < s.length(); i++) {
				if (s.charAt(i) > s.charAt(i - 1)) {
					min = s.charAt(i - 1);
				}
				StringBuffer stringNew = new StringBuffer(r);
				stringNew.append(min);
				StringBuffer string = new StringBuffer(s);
				string.deleteCharAt(min);
			}
		}
		return r;
	}

Wäre schön, wenn mir jemand helfen könnte,
Liebe Grüße

 

[Landei]

Du erzeugst innerhalb der Schleife immer wieder ein neues StringBuffer-Objekt für R, was hier kontraproduktiv ist. Erzeuge eines vor der Schleife, hänge immer wieder ein Zeichen an, und wandle es nach der Schleife in einen String um. Ähnlich kannst du auch für S vorgehen: Vor der Schleife einen Stringbuffer damit initialisieren, und dann davon immer ein Zeichen wegnehmen (wenn man die Aufgabe wörtlich nimmt, müsste man eigentlich immer "zwischendurch" Strings erzeugen, was hier aber wirklich blöd wäre).

Es kann natürlich auch sein, dass der Aufgabensteller im Sinn hatte, dass du nur mit Strings hantierst, was natürlich auch möglich, aber umständlicher (und letztendlich schlechter Stil) ist.

 

[Claudia92]

1)Ermittlung des aktuell kleinsten Zeichens C aus dem String S

Wie ergibt sich das "kleinste Zeichen"? Aus der Reihenfolge in der ASCII- bzw. Unicode-Tabelle?

Was wäre dann z. B. die Ausgabe von

sort("Java")

? "Jaav"?

 

[hüteüberhüte]

SelectionSort auf einem char[] würde sich hier doch anbieten. "R" fällt dabei einfach weg, es wird nur mit "S" hantiert

Werde beides später mal umsetzen

 

[Claudia92]

@_bella_: In deinem Quellcode sind mir einige Fehler aufgefallen, die ich im Folgenden markiert habe:

public static String sort(String s) {
        String r = "";
        char min = ' ';
        while (s != null) { // in deinem while-Block änderst du s nie und die Schleife würde daher endlos laufen
            for (int i = 1; i < s.length(); i++) {
                if (s.charAt(i) > s.charAt(i - 1)) { // wenn du das kleinste Zeichen finden willst, reicht es nicht, nur den Nachfolger zu betrachten
                    min = s.charAt(i - 1);
                }
                StringBuffer stringNew = new StringBuffer(r); // dass du hier in jedem Schleifendurchlauf neue Objekte erzeugst und dadurch den Inhalt der alten verlierst, hat Landei schon angesprochen
                stringNew.append(min);
                StringBuffer string = new StringBuffer(s);
                string.deleteCharAt(min); // die Methode deleteCharAt erwartet die Position des zu löschenden Characters - du übergibst hier aber einen Character. Das führt zu einer StringIndexOutOfBoundsException
            }
        }
        return r;
    }

Eine Lösung könnte in etwa so aussehen:

	public static String sort(String s) {
		StringBuffer stringOld = new StringBuffer(s);
		StringBuffer stringNew = new StringBuffer();

		while (stringOld.length() > 0) {
			int min = 0;
			for (int i = 1; i < stringOld.length(); i++)
				if (stringOld.charAt(i) < stringOld.charAt(min))
					min = i;
			stringNew.append(stringOld.charAt(min));
			stringOld.deleteCharAt(min);
		}
		return stringNew.toString();
	}

 

[hüteüberhüte]

Wenn hier schon fertige Lösungen gepostet werden, bin ich auch dabei:

    public static String sort(String s) {
        String r = "";
        while (s.length() != 0) {
            int index = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) >= s.charAt(index)) {
                    index = i;
                }
            }
            System.out.println(s.charAt(index));
            r += s.charAt(index);
            s = s.substring(0, index) + s.substring(index + 1, s.length());
        }
        return r;
    }

s.substring(0, index) + s.substring(index + 1, s.length())

funktioniert auch, wenn beginIndex == endIndex, denn:

beginIndex - the beginning index, inclusive. endIndex - the ending index, exclusive. [...]
IndexOutOfBoundsException - if the beginIndex is negative, or endIndex is larger than the length of this String object, or beginIndex is larger than endIndex.

Alles nicht sonderlich effizient

 

[hüteüberhüte]

[JAVA=6] if (s.charAt(i) >= s.charAt(index)) {[/code]

Es würde sogar

if (s.charAt(i) > s.charAt(index))

gehen (sort ist dann stabil)

[EDIT]

    public static String sort(String s) {
        String r = "";
        while (s.length() != 0) {
            int index = 0;  // 1)
            for (int i = 0; i < s.length(); i++) {  // 1)
                if (s.charAt(i) > s.charAt(index)) {  // 1)
                    index = i;  // 1)
                }
            }
            System.out.println(s.charAt(index));
            r += s.charAt(index);  // 2)
            s = s.substring(0, index) + s.substring(index + 1, s.length());  // 3)
        }
        return r;
    }

[/EDIT]

 

[Claudia92]

]

            for (int i = 0; i < s.length(); i++) {  // 1)
                if (s.charAt(i) > s.charAt(index)) {  // 1)
                    index = i;  // 1)
                }
            }

Ist das dann wirklich das kleinste Zeichen aus s? ???:L
Oder ist es Absicht, dass du absteigend sortierst?

 

[_bella_]

vielen Dank für die vielen schnellen Antworten...habe mir daraus eine funktionierende Lösung gebastelt
Liebe Grüße

 

[hüteüberhüte]

Ohje, hab mich mit der sortierung geirrt.

>

durch

<

ersetzen