• Algorithmes de Tri :

  • Tri par Sélection (Selection Sort)
  • Tri par Insertion (Insertion Sort)
  • Tri à Bulles (Bubble Sort)
  • Tri Fusion (Merge Sort)
  • Tri Rapide (Quick Sort)
  • Tri par Tas (Heap Sort)

• Algorithmes de Recherche :

  • Recherche Séquentielle (Linear Search)
  • Recherche Dichotomique (Binary Search)

• Complexité :

  • Notation Big-O
  • Complexité Temporelle
  • Complexité Spatiale
  • Analyse de la Complexité

• Listes (Lists) :

  • Liste chaînée (Linked List)
  • Liste doublement chaînée (Doubly Linked List)
  • Liste circulaire chaînée (Circular Linked List)
  • Liste circulaire doublement chaînée (Circular Doubly Linked List)

• Pile (Stack) – Principe LIFO (Last In, First Out) :

  • Opérations principales

• File (Queue) – Principe FIFO (First In, First Out) :

  • Opérations principales

• Arbres (Trees) :

  • Arbre Binaire (Binary Tree)
  • Arbre Binaire de Recherche (BST – Binary Search Tree)
  • Arbre Équilibré (AVL Tree)
  • Arbre Bicolores (Red-Black Tree)
  • Parcours (Traversal)

Cliquez sur les liens pour explorer les implémentations de chaque algorithme dans le dossier GitHub.

• Complexité : O(n²) (tous les cas).
• Trouve le plus petit élément et le place au début.

• Complexité : O(n²) (cas moyen et pire), O(n) (meilleur cas).
• Insère chaque élément à sa place dans une liste triée.

• Complexité : O(n²) (cas moyen et pire), O(n) (meilleur cas).
• Compare et échange des éléments adjacents.

• Complexité : O(n log n) (tous les cas).
• Divise et fusionne les sous-listes triées.

• Complexité : O(n log n) (cas moyen), O(n²) (pire cas).
• Divise la liste en sous-listes autour d’un pivot.

• Complexité : O(n log n) (tous les cas).
• Utilise une structure en tas pour trier.

Cliquez sur les liens pour accéder aux algorithmes de recherche sur GitHub.

• Complexité : O(n).
• Parcourt chaque élément jusqu’à trouver l’élément recherché.

• Complexité : O(log n) (liste triée).
• Divise la liste triée en deux moitiés pour localiser l’élément.

• Dossier des Algorithmes de Tri
• Dossier des Algorithmes de Recherche

• Définition : Décrit la borne supérieure du temps d'exécution d'un algorithme. Elle donne le pire des cas de la manière dont le temps d'exécution augmente avec la taille de l'entrée. Formellement, on dit que $f(n) = O(g(n))$ s'il existe des constantes positives $c$ et $n_0$ telles que : $0 \leq f(n) \leq c \cdot g(n)$ pour tout $n \geq n_0.$

• Classes courantes :

  • $O(1)$ : Temps constant.
  • $O(\log n)$ : Temps logarithmique.
  • $O(n)$ : Temps linéaire.
  • $O(n \log n)$ : Temps linéarithmique.
  • $O(n^2)$ : Temps quadratique.
  • $O(2^n)$ : Temps exponentiel.
  • $O(n!)$ : Temps factoriel.

• Définition : Mesure la quantité de temps qu'un algorithme prend pour s'exécuter en fonction de la longueur de l'entrée.
• Classes courantes :
  • P : Problèmes résolubles en temps polynomial.
  • NP : Problèmes pour lesquels une solution donnée peut être vérifiée en temps polynomial.
  • NP-difficile : Problèmes aussi difficiles que les problèmes les plus difficiles de NP ; pas nécessairement dans NP.
  • NP-complet : Problèmes de NP qui sont NP-difficiles.

• Définition : Mesure la quantité de mémoire qu'un algorithme utilise en fonction de la longueur de l'entrée.
• Classes courantes :
  • PSPACE : Problèmes résolubles en utilisant une quantité polynomiale d'espace.
  • L : Problèmes résolubles en espace logarithmique.
  • NL : Problèmes résolubles en espace logarithmique non déterministe.

• Cas moyen : Représente la complexité dans la plupart des situations.
• Pire cas : La complexité la plus élevée, souvent analysée avec la notation $Big-O$.
• Meilleur cas : La complexité minimale, mais rarement utilisée pour évaluer les performances globales.

Cliquez sur les liens pour explorer les implémentations dans le dossier GitHub.

Une liste est une collection ordonnée d’éléments stockés dynamiquement en mémoire.

Chaque élément (nœud) contient une valeur et un pointeur vers le nœud suivant. L’accès est séquentiel mais l’insertion et la suppression sont rapides.

Chaque nœud a deux pointeurs : un vers l’élément précédent et un vers l’élément suivant. Permet une navigation plus flexible.

Le dernier nœud pointe vers le premier, formant une boucle. Peut être simple ou doublement chaînée.

Version avancée où chaque nœud a deux pointeurs (précédent et suivant) et forme une boucle avec le premier et le dernier élément.

Une pile fonctionne comme une pile d’assiettes : on ajoute et on enlève par le haut | 🌐 Voir La Visualisation

• Empiler (Push) : Ajoute un nouvel élément à la pile.
• Dépiler (Pop) : Supprime et retourne l'élément du sommet de la pile.
• estVide (isEmpty) : Vérifie si la pile est Vide.
• estPleine (isFull) : Vérifier si la pile est Pleine.

Une file fonctionne comme une file d’attente : le premier arrivé est le premier servi | 🌐 Voir La Visualisation

• Enfiler (Enqueue) : Ajoute un nouvel élément à la file.
• Défiler (Dequeue) : Supprime et retourne le premier élément de la file.
• estVide (isEmpty) : Vérifie si la file est Vide.
• estPleine (isFull) : Vérifier si la file est Pleine.

Un Arbre est une structure de données hiérarchique composée de nœuds, où chaque nœud a un parent unique, sauf la racine qui n'a pas de parent.

• Root (Racine) : Le nœud au sommet de l'arbre, sans parent.

  • Dans l'arbre : A est la racine.

• Node (Nœud) : Un élément de l'arbre qui contient des données et peut avoir des enfants.

  • Dans l'arbre : A, B, C, D, E, F sont des nœuds.

• Edge (Arête) : Un lien entre deux nœuds, représentant une relation parent-enfant.

  • Dans l'arbre : A → B, A → C, B → D, B → E, C → F sont des arêtes.

• Leaf (Feuille) : Un nœud sans enfants.

  • Dans l'arbre : D, E, F sont des feuilles.

• Parent (Parent) : Un nœud qui a un ou plusieurs enfants.

  • Dans l'arbre : A est le parent de B et C. B est le parent de D et E. C est le parent de F.

• Child (Enfant) : Un nœud qui a un parent.

  • Dans l'arbre : B et C sont les enfants de A. D, E, et F sont les enfants de B et C.

• Sibling (Frère) : Des nœuds qui partagent le même parent.

  • Dans l'arbre : B et C sont frères. D et E sont frères.

• Subtree (Sous-arbre) : Une partie de l'arbre qui commence à un nœud et inclut tous ses descendants.

  • Dans l'arbre : Le sous-arbre de B est :

• Depth (Profondeur) : La distance entre un nœud et la racine, mesurée en nombre d'arêtes.

  • Dans l'arbre : La profondeur de A est 0. La profondeur de B et C est 1. La profondeur de D, E, et F est 2.

• Height (Hauteur) : La distance entre la racine et la feuille la plus éloignée.

  • Dans l'arbre : La hauteur de l'arbre est 2.

• Ancestor (Ancêtre) : Un nœud qui se trouve sur le chemin entre un nœud et la racine.

  • Dans l'arbre : Les ancêtres de D sont B et A.

• Descendant (Descendant) : Un nœud qui se trouve sur le chemin entre un nœud et une feuille.

  • Dans l'arbre : Les descendants de A sont B, C, D, E, F.

• Degree (Degré) : Le nombre d'enfants d'un nœud.

  • Dans l'arbre : Le degré de A est 2. Le degré de B est 2. Le degré de C est 1. Le degré de D, E, et F est 0.

• Level (Niveau) : La profondeur d'un nœud + 1.

  • Dans l'arbre : A est au niveau 1. B et C sont au niveau 2. D, E, et F sont au niveau 3.

• Path (Chemin) : Une séquence de nœuds connectés par des arêtes, allant d'un nœud à un autre.

  • Dans l'arbre : Le chemin de A à D est : A → B → D.

Un arbre binaire est un arbre tel que les nœuds ont au plus deux fils (gauche et droit).

Un arbre binaire de recherche est un arbre binaire qui possède la propriété suivante :

• Tous les nœuds du sous-arbre de gauche d’un nœud de l’arbre ont une valeur inferieure ou égale à la sienne.
• Tous les nœuds du sous-arbre de droite d’un nœud de l’arbre ont une valeur supérieure ou égale à la sienne.

Un arbre AVL (du nom de ses inventeurs Adelson-Velsky et Landis) est un arbre binaire de recherche équilibré dans lequel, pour tout nœud $x$ de l’arbre AVL.

$\text{eq}(x) = h(A_g(x)) - h(A_d(x)) \in {-1, 0, 1}$

où :

• $A_g(x)$ : sous-arbre gauche de $x$
• $A_d(x)$ : sous-arbre droit de $x$
• $h(\cdot)$ : fonction hauteur d’un sous-arbre

Un arbre bicolore Equilibré est un arbre binaire de recherche dans lequel chaque nœud a un attribut supplémentaire : sa couleur, qui est soit rouge soit noire.

Le parcours est un processus systématique qui consiste à visiter tous les nœuds d'un arbre dans un ordre spécifique. L'objectif est d'accéder à chaque nœud une fois, souvent pour effectuer une opération (comme la recherche, l'insertion, la suppression, etc.).

• Les nœuds sont visités niveau par niveau, de gauche à droite.

• Parcours Préfixe (Pré-ordre) :

  • D'abord, le nœud racine est visité.
  • Ensuite, tous les nœuds du sous-arbre gauche sont visités.
  • Et enfin, tous les nœuds du sous-arbre droit sont visités.

• Parcours Infixe (En-Ordre) :

  • Cela commence par visiter tous les nœuds du sous-arbre gauche.
  • Ensuite, on visite le nœud racine.
  • Et enfin, tous les nœuds du sous-arbre droit sont visités.

• Parcours Postfixe (Suffixe) :

  • Cela commence par les nœuds du sous-arbre gauche
  • Ensuite, les nœuds du sous-arbre droit sont visités
  • Et enfin, le nœud racine est visité