Structures de Données

Exemple complet

int x = 42;
int *p = &x;   // p contient l'adresse de x

printf("%d", x);   // 42  (valeur directe)
printf("%p", p);   // 0x1000  (adresse stockée dans p)
printf("%d", *p);  // 42  (valeur à l'adresse pointée par p)

*p = 100;          // modifie x via le pointeur !
printf("%d", x);   // 100

Exemple complet annoté

#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int *p1 = &a;
    int *p2 = &b;

    printf("a = %d, b = %d\n", a, b);         // a = 10, b = 20
    printf("*p1 = %d, *p2 = %d\n", *p1, *p2); // *p1 = 10, *p2 = 20

    // Échanger a et b via pointeurs
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;

    printf("Après échange :\n");
    printf("a = %d, b = %d\n", a, b);  // a = 20, b = 10

    return 0;
}

Pointeur sur pointeur (**)

int x = 42;
int *p = &x;    // p pointe vers x
int **pp = &p;  // pp pointe vers p

printf("%d\n", **pp);  // 42  (double déréférencement)

malloc — Memory ALLOCate

#include <stdlib.h>

// Syntaxe :
void *malloc(size_t taille_en_octets);
// Retourne un pointeur void* vers le bloc alloué, ou NULL si échec.

// Allouer un entier dynamiquement
int *p = (int*) malloc(sizeof(int));
if (p == NULL) {
    printf("Erreur d'allocation !\n");
    return 1;
}
*p = 42;
printf("%d\n", *p);
free(p);  // TOUJOURS libérer la mémoire !
p = NULL; // bonne pratique

// Allouer un tableau de 10 entiers
int *tab = (int*) malloc(10 * sizeof(int));
for (int i = 0; i < 10; i++) tab[i] = i * 2;
free(tab);

calloc — Cleared ALLOCate

void *calloc(size_t nb_elements, size_t taille_element);
// Alloue ET initialise tout à 0.

int *tab = (int*) calloc(10, sizeof(int));
// tab[0]..tab[9] valent tous 0 automatiquement
// malloc n'initialise PAS → contient des "déchets" mémoire

free(tab);

realloc — REALLOCate

// Redimensionner un bloc alloué
int *tab = (int*) malloc(5 * sizeof(int));
tab = (int*) realloc(tab, 10 * sizeof(int));  // agrandir à 10

Opérations fondamentales

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    int taille;
    int capacite;
} TabDyn;

// Initialiser
TabDyn creer(int capacite_initiale) {
    TabDyn t;
    t.data = (int*) malloc(capacite_initiale * sizeof(int));
    t.taille = 0;
    t.capacite = capacite_initiale;
    return t;
}

// Ajouter un élément (avec redimensionnement si nécessaire)
void ajouter(TabDyn *t, int val) {
    if (t->taille == t->capacite) {
        // Doubler la capacité
        t->capacite *= 2;
        t->data = (int*) realloc(t->data, t->capacite * sizeof(int));
    }
    t->data[t->taille] = val;
    t->taille++;
}

// Afficher
void afficher(TabDyn *t) {
    printf("[");
    for (int i = 0; i < t->taille; i++) {
        printf("%d", t->data[i]);
        if (i < t->taille - 1) printf(", ");
    }
    printf("]\n");
}

// Libérer
void detruire(TabDyn *t) {
    free(t->data);
    t->data = NULL;
    t->taille = 0;
    t->capacite = 0;
}

int main() {
    TabDyn t = creer(4);
    ajouter(&t, 10);
    ajouter(&t, 20);
    ajouter(&t, 30);
    ajouter(&t, 40);
    ajouter(&t, 50);  // déclenche realloc
    afficher(&t);     // [10, 20, 30, 40, 50]
    detruire(&t);
    return 0;
}

Définition et création d'un nœud

typedef struct Noeud {
    int data;
    struct Noeud *suivant;  // pointeur vers le prochain nœud
} Noeud;

Noeud* creer_noeud(int val) {
    Noeud *n = (Noeud*) malloc(sizeof(Noeud));
    n->data = val;
    n->suivant = NULL;
    return n;
}

Opérations complètes

#include <stdio.h>
#include <stdlib.h>

typedef struct Noeud {
    int data;
    struct Noeud *suivant;
} Noeud;

// ─── Insertion en tête ───
void inserer_tete(Noeud **tete, int val) {
    Noeud *n = (Noeud*) malloc(sizeof(Noeud));
    n->data = val;
    n->suivant = *tete;  // le nouveau nœud pointe vers l'ancienne tête
    *tete = n;           // la tête devient le nouveau nœud
}

// ─── Insertion en queue ───
void inserer_queue(Noeud **tete, int val) {
    Noeud *n = (Noeud*) malloc(sizeof(Noeud));
    n->data = val;
    n->suivant = NULL;

    if (*tete == NULL) {
        *tete = n;
        return;
    }

    Noeud *courant = *tete;
    while (courant->suivant != NULL)
        courant = courant->suivant;  // avancer jusqu'au dernier
    courant->suivant = n;
}

// ─── Suppression par valeur ───
void supprimer(Noeud **tete, int val) {
    if (*tete == NULL) return;

    // Si c'est la tête à supprimer
    if ((*tete)->data == val) {
        Noeud *tmp = *tete;
        *tete = (*tete)->suivant;
        free(tmp);
        return;
    }

    Noeud *courant = *tete;
    while (courant->suivant != NULL && courant->suivant->data != val)
        courant = courant->suivant;

    if (courant->suivant != NULL) {
        Noeud *tmp = courant->suivant;
        courant->suivant = tmp->suivant;
        free(tmp);
    }
}

// ─── Affichage ───
void afficher_liste(Noeud *tete) {
    while (tete != NULL) {
        printf("%d → ", tete->data);
        tete = tete->suivant;
    }
    printf("NULL\n");
}

// ─── Libération totale ───
void liberer_liste(Noeud **tete) {
    Noeud *courant = *tete;
    while (courant != NULL) {
        Noeud *tmp = courant;
        courant = courant->suivant;
        free(tmp);
    }
    *tete = NULL;
}

int main() {
    Noeud *liste = NULL;
    inserer_tete(&liste, 30);
    inserer_tete(&liste, 20);
    inserer_tete(&liste, 10);
    inserer_queue(&liste, 40);
    afficher_liste(liste);   // 10 → 20 → 30 → 40 → NULL
    supprimer(&liste, 20);
    afficher_liste(liste);   // 10 → 30 → 40 → NULL
    liberer_liste(&liste);
    return 0;
}

Implémentation avec liste chaînée

#include <stdio.h>
#include <stdlib.h>

typedef struct Noeud {
    int data;
    struct Noeud *suivant;
} Noeud;

typedef struct {
    Noeud *sommet;
    int taille;
} Pile;

// Initialiser
Pile creer_pile() {
    Pile p;
    p.sommet = NULL;
    p.taille = 0;
    return p;
}

int est_vide(Pile *p) {
    return p->sommet == NULL;
}

// Push : insérer en tête = au sommet
void push(Pile *p, int val) {
    Noeud *n = (Noeud*) malloc(sizeof(Noeud));
    n->data = val;
    n->suivant = p->sommet;
    p->sommet = n;
    p->taille++;
}

// Pop : retirer la tête = le sommet
int pop(Pile *p) {
    if (est_vide(p)) {
        printf("Pile vide !\n");
        return -1;  // valeur sentinelle
    }
    Noeud *tmp = p->sommet;
    int val = tmp->data;
    p->sommet = tmp->suivant;
    free(tmp);
    p->taille--;
    return val;
}

// Peek : lire sans retirer
int peek(Pile *p) {
    if (est_vide(p)) {
        printf("Pile vide !\n");
        return -1;
    }
    return p->sommet->data;
}

void afficher_pile(Pile *p) {
    printf("Sommet → ");
    Noeud *courant = p->sommet;
    while (courant != NULL) {
        printf("[%d] ", courant->data);
        courant = courant->suivant;
    }
    printf("\n");
}

int main() {
    Pile p = creer_pile();
    push(&p, 10);
    push(&p, 20);
    push(&p, 30);
    afficher_pile(&p);     // Sommet → [30] [20] [10]
    printf("Pop: %d\n", pop(&p));  // 30
    printf("Peek: %d\n", peek(&p)); // 20
    afficher_pile(&p);     // Sommet → [20] [10]
    return 0;
}

Application classique : vérification de parenthèses

int verifier_parentheses(char *expr) {
    Pile p = creer_pile();
    for (int i = 0; expr[i] != '\0'; i++) {
        if (expr[i] == '(') push(&p, '(');
        else if (expr[i] == ')') {
            if (est_vide(&p)) return 0;  // fermante sans ouvrante
            pop(&p);
        }
    }
    return est_vide(&p);  // 1 si équilibré, 0 sinon
}

Implémentation avec liste chaînée (tête + queue)

#include <stdio.h>
#include <stdlib.h>

typedef struct Noeud {
    int data;
    struct Noeud *suivant;
} Noeud;

typedef struct {
    Noeud *tete;   // où on défile (côté sortie)
    Noeud *queue;  // où on enfile (côté entrée)
    int taille;
} File;

File creer_file() {
    File f;
    f.tete = NULL;
    f.queue = NULL;
    f.taille = 0;
    return f;
}

int file_vide(File *f) {
    return f->tete == NULL;
}

// Enfiler : ajouter en queue
void enfiler(File *f, int val) {
    Noeud *n = (Noeud*) malloc(sizeof(Noeud));
    n->data = val;
    n->suivant = NULL;

    if (file_vide(f)) {
        f->tete = n;
        f->queue = n;
    } else {
        f->queue->suivant = n;
        f->queue = n;
    }
    f->taille++;
}

// Défiler : retirer en tête
int defiler(File *f) {
    if (file_vide(f)) {
        printf("File vide !\n");
        return -1;
    }
    Noeud *tmp = f->tete;
    int val = tmp->data;
    f->tete = tmp->suivant;
    if (f->tete == NULL) f->queue = NULL;  // file devenue vide
    free(tmp);
    f->taille--;
    return val;
}

int front(File *f) {
    if (file_vide(f)) return -1;
    return f->tete->data;
}

void afficher_file(File *f) {
    printf("Tête → ");
    Noeud *courant = f->tete;
    while (courant != NULL) {
        printf("[%d] ", courant->data);
        courant = courant->suivant;
    }
    printf("← Queue\n");
}

int main() {
    File f = creer_file();
    enfiler(&f, 10);
    enfiler(&f, 20);
    enfiler(&f, 30);
    afficher_file(&f);          // Tête → [10] [20] [30] ← Queue
    printf("Défile: %d\n", defiler(&f));  // 10
    printf("Front: %d\n", front(&f));     // 20
    afficher_file(&f);          // Tête → [20] [30] ← Queue
    return 0;
}

Définition du nœud

typedef struct Noeud {
    int data;
    struct Noeud *gauche;
    struct Noeud *droite;
} Noeud;

Implémentation complète ABR

#include <stdio.h>
#include <stdlib.h>

typedef struct Noeud {
    int data;
    struct Noeud *gauche;
    struct Noeud *droite;
} Noeud;

// ─── Créer un nœud ───
Noeud* creer_noeud(int val) {
    Noeud *n = (Noeud*) malloc(sizeof(Noeud));
    n->data = val;
    n->gauche = NULL;
    n->droite = NULL;
    return n;
}

// ─── Insertion BST ───
Noeud* inserer(Noeud *racine, int val) {
    if (racine == NULL) return creer_noeud(val);
    if (val < racine->data)
        racine->gauche = inserer(racine->gauche, val);
    else if (val > racine->data)
        racine->droite = inserer(racine->droite, val);
    // si val == racine->data : ignorer (pas de doublons)
    return racine;
}

// ─── Recherche ───
int rechercher(Noeud *racine, int val) {
    if (racine == NULL) return 0;         // non trouvé
    if (val == racine->data) return 1;    // trouvé
    if (val < racine->data)
        return rechercher(racine->gauche, val);
    return rechercher(racine->droite, val);
}

// ─── Parcours In-Ordre (gauche, racine, droite) ───
// → donne les valeurs dans l'ordre croissant pour un BST !
void inordre(Noeud *racine) {
    if (racine == NULL) return;
    inordre(racine->gauche);
    printf("%d ", racine->data);
    inordre(racine->droite);
}

// ─── Parcours Pré-Ordre (racine, gauche, droite) ───
void preordre(Noeud *racine) {
    if (racine == NULL) return;
    printf("%d ", racine->data);
    preordre(racine->gauche);
    preordre(racine->droite);
}

// ─── Parcours Post-Ordre (gauche, droite, racine) ───
void postordre(Noeud *racine) {
    if (racine == NULL) return;
    postordre(racine->gauche);
    postordre(racine->droite);
    printf("%d ", racine->data);
}

// ─── Hauteur ───
int hauteur(Noeud *racine) {
    if (racine == NULL) return -1;
    int hg = hauteur(racine->gauche);
    int hd = hauteur(racine->droite);
    return 1 + (hg > hd ? hg : hd);
}

// ─── Libération ───
void liberer(Noeud *racine) {
    if (racine == NULL) return;
    liberer(racine->gauche);
    liberer(racine->droite);
    free(racine);
}

int main() {
    Noeud *racine = NULL;
    int vals[] = {10, 5, 15, 3, 7, 12, 20};
    for (int i = 0; i < 7; i++)
        racine = inserer(racine, vals[i]);

    printf("In-ordre   : "); inordre(racine);   printf("\n"); // 3 5 7 10 12 15 20
    printf("Pré-ordre  : "); preordre(racine);  printf("\n"); // 10 5 3 7 15 12 20
    printf("Post-ordre : "); postordre(racine); printf("\n"); // 3 7 5 12 20 15 10
    printf("Hauteur    : %d\n", hauteur(racine));              // 2
    printf("Recherche 7 : %s\n", rechercher(racine, 7) ? "Trouvé" : "Absent");

    liberer(racine);
    return 0;
}

Suppression dans un BST

// Trouver le minimum d'un sous-arbre (pour suppression)
Noeud* min_noeud(Noeud *n) {
    while (n->gauche != NULL) n = n->gauche;
    return n;
}

Noeud* supprimer_bst(Noeud *racine, int val) {
    if (racine == NULL) return NULL;

    if (val < racine->data)
        racine->gauche = supprimer_bst(racine->gauche, val);
    else if (val > racine->data)
        racine->droite = supprimer_bst(racine->droite, val);
    else {
        // Cas 1 : feuille
        if (racine->gauche == NULL && racine->droite == NULL) {
            free(racine);
            return NULL;
        }
        // Cas 2 : un seul fils
        if (racine->gauche == NULL) {
            Noeud *tmp = racine->droite;
            free(racine);
            return tmp;
        }
        if (racine->droite == NULL) {
            Noeud *tmp = racine->gauche;
            free(racine);
            return tmp;
        }
        // Cas 3 : deux fils → remplacer par le successeur in-ordre
        Noeud *successeur = min_noeud(racine->droite);
        racine->data = successeur->data;
        racine->droite = supprimer_bst(racine->droite, successeur->data);
    }
    return racine;
}