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.