Salut,

Recherchez-vous une structure de données qui stocke des valeurs uniques, vous permet d'insérer des valeurs, de rechercher le nombre total de valeurs et de supprimer des valeurs ? Le choix idéal pour cela est un Set. De nombreux langages de programmation incluent une structure de données Set intégrée, et JavaScript ne fait pas exception. Examinons plus en détail le fonctionnement des ensembles.

Qu'est-ce que Définir ?
Le Set est une structure de données qui vous permet de stocker des valeurs uniques de tout type, qu'il s'agisse de valeurs primitives ou de références d'objet. L'ensemble permet des opérations d'insertion, de suppression, de mise à jour et de taille avec une complexité temporelle O(1). Ce qui rend l'installation plus rapide et efficace.

Les ensembles sont conçus pour offrir des temps d'accès rapides. Ils sont généralement mis en œuvre de manière à accélérer la recherche des éléments plutôt que de simplement vérifier chaque élément un par un. L'implémentation typique peut être une table de hachage (recherche O(1)) ou un arbre de recherche (recherche O(log(N))).

Points clés

• Accès rapide : les ensembles fournissent un accès rapide aux éléments.
• Mise en œuvre : généralement implémentée à l'aide de tables de hachage ou d'arbres de recherche.
• Temps de recherche : le temps de recherche moyen est meilleur que O(N), souvent O(1) ou O(log(N)).

Méthodes de base

1. add : cela ajoutera un élément à définir. Si l'élément est présent dans set, il ne fera rien.
2. has : Il retournera vrai si l'élément est présent dans l'ensemble, sinon faux.
3. size : Il renverra la taille de l'ensemble.
4. delete : cela supprimera l'élément de l'ensemble.
5. keys : La méthode .keys() dans un Set JavaScript renvoie un nouvel objet itérateur qui contient les valeurs du Set dans l'ordre dans lequel elles ont été insérées.

Exemples

// 1. Create a new Set and use the .add() method to add elements
const mySet = new Set();
mySet.add(10);
mySet.add(20);
mySet.add(30);

console.log(mySet); // Output: Set { 10, 20, 30 }

// 2. Check if the Set has a specific element using .has() method
console.log(mySet.has(20)); // Output: true
console.log(mySet.has(40)); // Output: false

// 3. Delete an element from the Set using .delete() method
mySet.delete(20);
console.log(mySet); // Output: Set { 10, 30 }

// 4. Iterate over the Set using .keys() method
// In Sets, .keys() and .values() do the same thing
for (const key of mySet.keys()) {
  console.log(key);
}
// Output:
// 10
// 30

// 5. Get the size of the Set using .size property
console.log(mySet.size); // Output: 2

Exemple d'ensemble avec problème de leetcode :

3. Sous-chaîne la plus longue sans caractères répétitifs

Étant donné une chaîne s, recherchez la longueur de la sous-chaîne la plus longue sans répéter de caractères.

Solution

/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLongestSubstring = function(s) {
    let set = new Set();
    let ans = 0;
    let s_index = 0;
    for (let i = 0; i 



Explication: 

La fonction lengthOfLongestSubstring utilise une technique de fenêtre glissante avec un Set pour trouver la sous-chaîne la plus longue sans répéter de caractères :

• Agrandir la fenêtre : ajoutez des personnages à l'ensemble s'ils ne sont pas déjà présents.
• Réduire la fenêtre : supprimez les caractères du début de la fenêtre lorsque des doublons sont trouvés, en ajustant la taille de la fenêtre.
• Mettre à jour la longueur : suivez la longueur maximale de la sous-chaîne avec des caractères uniques.
• L'approche garantit une complexité temporelle O(N) efficace en traitant chaque caractère au plus deux fois.

C'est tout, si vous avez des doutes, des suggestions ou quoi que ce soit, n'hésitez pas à ajouter des commentaires.

Sources :
MDN (Ensemble)