Quelles sont les structures de données existantes…

Il existe les structures de données principales suivantes :

Primaires :

Nombres entiers (Integer)
Nombres à virgule flottante (Floating-point numbers)
Valeurs booléennes (Boolean)
Caractères (Character)

Abstraites :

Tableau (Array) : Collection ordonnée d'éléments du même type, accès par indice avec un temps constant.
Liste chaînée (Linked List) : Collection de nœuds, chacun contenant des données et une référence au nœud suivant. Ajout/suppression efficaces au début/fin, accès par indice - $O(n)$.
- Liste simplement chaînée (Singly Linked List)
- Liste doublement chaînée (Doubly Linked List)
- Liste circulaire (Circular Linked List)

Pile (Stack) : Structure LIFO (Last-In, First-Out). Opérations : push (ajouter), pop (retirer), peek (voir le sommet).

struct Stack<Element> {
    private var elements: [Element] = []

    mutating func push(_ element: Element) {
        elements.append(element)
    }

    mutating func pop() -> Element? {
        return elements.popLast()
    }

    func peek() -> Element? {
        return elements.last
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }
}

File d'attente (Queue) : Structure FIFO (First-In, First-Out). Opérations : enqueue (ajouter), dequeue (retirer), peek (voir le premier).

struct Queue<Element> {
    private var elements: [Element] = []

    mutating func enqueue(_ element: Element) {
        elements.append(element)
    }

    mutating func dequeue() -> Element? {
        guard !elements.isEmpty else { return nil }
        return elements.removeFirst()
    }

    func peek() -> Element? {
        return elements.first
    }

    var isEmpty: Bool {
        return elements.isEmpty
    }
}

Table de hachage (Hash Table) / Dictionnaire (Dictionary) / Tableau associatif (Associative Array) : Collection de paires "clé-valeur", permettant une recherche, insertion et suppression efficaces par clé en utilisant une fonction de hachage.
```
var dictionary = [String: Any]() // Exemple de dictionnaire en Swift
dictionary["key1"] = "value1"
let value = dictionary["key1"]
```
Ensemble (Set) : Collection non ordonnée d'éléments uniques. Supporte les opérations : ajout, suppression, vérification d'existence, union, intersection, différence.
```
var set: Set<Int> = [1, 2, 3] // Exemple d'ensemble en Swift
set.insert(4)
let containsTwo = set.contains(2)
```
Arbre (Tree) : Structure hiérarchique de données, composée de nœuds liés par des arêtes. Possède un nœud racine et des nœuds enfants.
- Arbre binaire (Binary Tree)
- Arbre binaire de recherche (Binary Search Tree - BST)
- Arbre binaire équilibré (Balanced Binary Tree) - AVL, arbre rouge-noir.
- Arbre B (B-Tree)
Graphe (Graph) : Ensemble de sommets (nœuds) et d'arêtes (liens) connectant les sommets. Peut être orienté ou non, pondéré ou non.

Comprendre ces structures de données est essentiel pour écrire un code efficace et évolutif. Le choix de la structure appropriée dépend des exigences de performance (recherche, insertion, suppression) et de la nature des données.

Quelles sont les structures de données existantes?