TOC

Suppression des caractères répétés d’une chaîne

Supprimer des caractères répétés d'une chaîne

1. Vue d'ensemble

Dans ce didacticiel, nous aborderons plusieurs techniques en Java sur la façon de supprimer des caractères répétés d'une chaîne.

Pour chaque technique,we’ll also talk briefly about its time and space complexity.

2. Utilisation dedistinct

Commençons par supprimer les doublons de notre chaîne en utilisant la méthodedistinct introduite dans Java 8.

Ci-dessous, nous obtenons une instance d'unIntStream à partir d'un objet chaîne donné. Ensuite, nous utilisons la méthodedistinct pour supprimer les doublons. Enfin, nous appelons la méthodeforEach pour boucler sur les caractères distincts et les ajouter à nosStringBuilder: 

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

Time Complexity: O(n) - le temps d'exécution de la boucle est directement proportionnel à la taille de la chaîne d'entrée

Auxiliary Space:O(n) - puisquedistinct utilise unLinkedHashSet en interne et que nous stockons également la chaîne résultante dans un objetStringBuilder

Maintains Order: Oui - puisque leLinkedHashSet perd l'ordre de ses éléments

Et, bien que ce soit bien que Java 8 accomplisse si bien cette tâche pour nous, comparons-le aux efforts déployés pour lancer le nôtre.

3. Utilisation deindexOf

L'approche naïve pour supprimer les doublons d'une chaîne implique simplementlooping 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) - pour chaque caractère, la méthodeindexOf parcourt la chaîne restante

Auxiliary Space:O(n) - un espace linéaire est nécessaire car nous utilisons lesStringBuilder pour stocker le résultat

Maintains Order: Oui

Cette méthode a la même complexité spatiale que la première approche maisperforms much slower.

4. Utiliser un tableau de caractères

Nous pouvons également supprimer les doublons de notre chaîne parconverting it into a char array and then looping over each character and comparing it to all subsequent characters.

Comme nous pouvons le voir ci-dessous, nous créons deux bouclesfor et nous vérifions si chaque élément est répété dans la chaîne. Si un doublon est trouvé, nous ne l'ajoutons pas auxStringBuilder: 

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) - nous avons une boucle interne et une boucle externe traversant la chaîne d'entrée

Auxiliary Space:O(n) - un espace linéaire est requis car la variablechars stocke une nouvelle copie de l'entrée de chaîne et nous utilisons également lesStringBuilder pour enregistrer le résultat

Maintains Order: Oui

Encore une fois, notre deuxième tentative fonctionne mal par rapport à l'offre Core Java, mais voyons où nous en sommes avec notre prochaine tentative.

5. Utiliser le tri

Alternativement, les caractères répétés peuvent être éliminés en triant notre chaîne d'entrée pour regrouper les doublons. 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.

À chaque itération, nous allons comparer chaque élément du tableau avec l’élément précédent. Si les éléments sont différents, nous ajouterons le caractère actuel auxStringBuilder: 

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) - le tri utilise undual-pivot Quicksort qui offre des performances O (n log n) sur de nombreux ensembles de données

Auxiliary Space:O(n) - puisque la méthodetoCharArray fait une copie de l'entréeString

Maintains Order: Non

Réessayons avec notre dernière tentative.

6. Utilisation d'unSet

Une autre façon de supprimer des caractères répétés d'une chaîne consiste à utiliser unSet. 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.

Dans les deux cas, nous allons boucler sur la chaîne d'entrée et ajouter chaque caractère auxSet. Une fois les caractères insérés dans l'ensemble, nous allons parcourir celui-ci pour les ajouter au retour de sableStringBuilder de la chaîne résultante: 

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) - le temps d'exécution de la boucle est directement proportionnel à la taille de la chaîne d'entrée

Auxiliary Space:O(n) - l'espace requis pour lesSet dépend de la taille de la chaîne d'entrée; aussi, nous utilisons lesStringBuilder pour stocker le résultat

Maintains Order:LinkedHashSet –  Oui,HashSet – Non

Et maintenant, nous avons adopté l'approche Core Java! Ce n’est pas très choquant de découvrir que cela ressemble beaucoup à ce que fait déjàdistinct.

7. Conclusion

In this article, we covered a few ways to remove repeated characters from a string in Java. Nous avons également examiné la complexité temporelle et spatiale de chacune de ces méthodes.

Comme toujours, des extraits de code peuvent être trouvésover on GitHub.

Related