TOC

Wiederholte Zeichen aus einer Zeichenfolge entfernen

Wiederholte Zeichen aus einem String entfernen

1. Überblick

In diesem Tutorial werden verschiedene Techniken in Java zum Entfernen wiederholter Zeichen aus einer Zeichenfolge erläutert.

Für jede Technikwe’ll also talk briefly about its time and space complexity.

2. Verwenden vondistinct

Beginnen wir damit, die Duplikate mit der in Java 8 eingeführten Methodedistinctaus unserer Zeichenfolge zu entfernen.

Im Folgenden erhalten wir eine Instanz vonIntStream von einem bestimmten Zeichenfolgenobjekt. Dann verwenden wir diedistinct-Methode, um die Duplikate zu entfernen. Schließlich rufen wir dieforEach-Methode auf, um die verschiedenen Zeichen zu durchlaufen und sie an unsereStringBuilder anzuhängen: 

StringBuilder sb = new StringBuilder();
str.chars().distinct().forEach(c -> sb.append((char) c));

Time Complexity: O(n) - Die Laufzeit der Schleife ist direkt proportional zur Größe der Eingabezeichenfolge

Auxiliary Space:O(n) - dadistinct internLinkedHashSet verwendet und wir die resultierende Zeichenfolge auch in einemStringBuilder-Objekt speichern

Maintains Order: Ja - daLinkedHashSet die Reihenfolge seiner Elemente beibehält

Und obwohl es schön ist, dass Java 8 diese Aufgabe so gut für uns erledigt, vergleichen wir sie mit den Bemühungen, unsere eigenen zu rollen.

3. Verwenden vonindexOf

Der naive Ansatz zum Entfernen von Duplikaten aus einer Zeichenfolge umfasst einfachlooping over the input and using the indexOf method to check whether the current character already exists in the resulting string: 

StringBuilder sb = new StringBuilder();
int idx;
for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);
    idx = str.indexOf(c, i + 1);
    if (idx == -1) {
        sb.append(c);
    }
}

Time Complexity: O(n * n) - Für jedes Zeichen durchläuft die MethodeindexOf die verbleibende Zeichenfolge

Auxiliary Space:O(n) - linearer Speicherplatz ist erforderlich, da wir dieStringBuilder zum Speichern des Ergebnisses verwenden

Maintains Order: Ja

Diese Methode hat die gleiche Raumkomplexität wie der erste Ansatz, jedochperforms much slower.

4. Verwenden eines Zeichenarrays

Wir können Duplikate auch umconverting it into a char array and then looping over each character and comparing it to all subsequent characters aus unserer Zeichenfolge entfernen.

Wie wir unten sehen können, erstellen wir zweifor-Schleifen und prüfen, ob jedes Element in der Zeichenfolge wiederholt wird. Wenn ein Duplikat gefunden wird, hängen wir es nicht anStringBuilder an: 

char[] chars = str.toCharArray();
StringBuilder sb = new StringBuilder();
boolean repeatedChar;
for (int i = 0; i < chars.length; i++) {
    repeatedChar = false;
    for (int j = i + 1; j < chars.length; j++) {
        if (chars[i] == chars[j]) {
            repeatedChar = true;
            break;
        }
    }
    if (!repeatedChar) {
        sb.append(chars[i]);
    }
}

Time Complexity: O(n * n) - Wir haben eine innere und eine äußere Schleife, die beide die Eingabezeichenfolge durchlaufen

Auxiliary Space:O(n) - linearer Speicherplatz ist erforderlich, da die Variablechars eine neue Kopie der Zeichenfolgeneingabe speichert und wir auch dieStringBuilder verwenden, um das Ergebnis zu speichern

Maintains Order: Ja

Auch hier ist unser zweiter Versuch im Vergleich zum Core Java-Angebot schlecht, aber lassen Sie uns sehen, wo wir bei unserem nächsten Versuch hinkommen.

5. Sortieren verwenden

Alternativ können wiederholte Zeichen eliminiert werden, indem die Eingabezeichenfolge sortiert wird, um Duplikate zu gruppieren. In order to do that, we have to convert the string to a char array and sort it using the Arrays.sort method. Finally, we’ll iterate over the sorted char array.

Während jeder Iteration werden wir jedes Element des Arrays mit dem vorherigen Element vergleichen. Wenn die Elemente unterschiedlich sind, hängen wir das aktuelle Zeichen anStringBuilder: an 

StringBuilder sb = new StringBuilder();
if(!str.isEmpty()) {
    char[] chars = str.toCharArray();
    Arrays.sort(chars);

    sb.append(chars[0]);
    for (int i = 1; i < chars.length; i++) {
        if (chars[i] != chars[i - 1]) {
            sb.append(chars[i]);
        }
    }
}

Time Complexity: O(n log n) - Die Sortierung verwendetdual-pivot Quicksort, was für viele Datensätze eine O (n log n) -Leistung bietet

Auxiliary Space:O(n) - da die MethodetoCharArray eine Kopie der EingabeString erstellt

Maintains Order: Nr

Versuchen wir es noch einmal mit unserem letzten Versuch.

6. Verwenden vonSet

Eine andere Möglichkeit, wiederholte Zeichen aus einer Zeichenfolge zu entfernen, ist die Verwendung vonSet. If we do not care about the order of characters in our output string we can use a HashSet.Otherwise, we can use a LinkedHashSet to maintain the insertion order.

In beiden Fällen durchlaufen wir die Eingabezeichenfolge und fügen jedes Zeichen zuSet hinzu. Sobald die Zeichen in die Menge eingefügt wurden, werden wir sie wiederholen, um sie demStringBuilder -Sand hinzuzufügen. Geben Sie die resultierende Zeichenfolge zurück: 

StringBuilder sb = new StringBuilder();
Set linkedHashSet = new LinkedHashSet<>();

for (int i = 0; i < str.length(); i++) {
    linkedHashSet.add(str.charAt(i));
}

for (Character c : linkedHashSet) {
    sb.append(c);
}

Time Complexity: O(n) - Die Laufzeit der Schleife ist direkt proportional zur Größe der Eingabezeichenfolge

Auxiliary Space:O(n) - Der fürSet erforderliche Speicherplatz hängt von der Größe der Eingabezeichenfolge ab. Außerdem verwenden wirStringBuilder, um das Ergebnis zu speichern

Maintains Order:LinkedHashSet – Ja,HashSet – Nr

Und jetzt haben wir den Core Java-Ansatz angepasst! Es ist nicht sehr schockierend herauszufinden, dass dies sehr ähnlich zu dem ist, wasdistinctbereits tut.

7. Fazit

In this article, we covered a few ways to remove repeated characters from a string in Java. Wir haben uns auch die zeitliche und räumliche Komplexität jeder dieser Methoden angesehen.

Wie immer können Codefragmenteover on GitHub gefunden werden.

Related