Tableau multidimensionnel : Structure de données qui stocke des éléments organisés selon plusieurs dimensions (2D, 3D, etc.).
- Déclarer la matrice avec des dimensions fixes
- Spécifier le nombre de lignes et de colonnes
- Initialiser les éléments (optionnel)
- Accéder aux éléments par leurs coordonnées
│ matrice[0][0]│ matrice[0][1]│ matrice[0][2]│ ← Ligne 0
│ 1 │ 2 │ 3 │
├─────────────┼─────────────┼─────────────┤
│ matrice[1][0]│ matrice[1][1]│ matrice[1][2]│ ← Ligne 1
│ 4 │ 5 │ 6 │
├─────────────┼─────────────┼─────────────┤
│ matrice[2][0]│ matrice[2][1]│ matrice[2][2]│ ← Ligne 2
│ 7 │ 8 │ 9 │
└─────────────┴─────────────┴─────────────┘
Matrice 3x3 avec coordonnées et valeurs
Spécifier le type des éléments et les dimensions [lignes][colonnes]
Utiliser deux indices [ligne][colonne] allant de 0 à n-1
Affecter des valeurs à chaque case de la matrice
Matrice déclarée et initialisée avec des valeurs accessibles par coordonnées
• Indices : Commencent à 0 et vont jusqu'à dimension-1
• Homogénéité : Tous les éléments sont du même type
• Accès : Direct par les coordonnées en temps constant O(1)
Accès aux éléments : Opération qui permet de lire ou modifier la valeur d'un élément à des coordonnées données.
│ grille[0][0]│ grille[0][1]│ grille[0][2]│ grille[0][3]│ ← Ligne 0
│ 0 │ 1 │ 2 │ 3 │
├─────────────┼─────────────┼─────────────┼─────────────┤
│ grille[1][0]│ grille[1][1]│ grille[1][2]│ grille[1][3]│ ← Ligne 1
│ 4 │ 5 │ 6 │ 7 │
├─────────────┼─────────────┼─────────────┼─────────────┤
│ grille[2][0]│ grille[2][1]│ grille[2][2]│ grille[2][3]│ ← Ligne 2
│ 8 │ 99 │ 10 │ 11 │ ← Élément modifié!
├─────────────┼─────────────┼─────────────┼─────────────┤
│ grille[3][0]│ grille[3][1]│ grille[3][2]│ grille[3][3]│ ← Ligne 3
│ 12 │ 13 │ 14 │ 15 │
└─────────────┴─────────────┴─────────────┴─────────────┘
Grille 4x4 avec l'élément [2][1] modifié
Utiliser les deux indices pour accéder à la valeur : grille[2][1]
Affecter une nouvelle valeur aux coordonnées : grille[2][1] ← 99
Utiliser des boucles imbriquées pour accéder à tous les éléments
Capacité à lire et modifier n'importe quel élément de la matrice
• Accès direct : O(1) - temps constant pour accéder à un élément
• Coordonnées valides : Vérifier que les indices sont dans les bornes
• Modification : Peut être faite directement par affectation
Somme d'une matrice : Calcul de la somme de tous les éléments en parcourant la matrice avec des boucles imbriquées.
│ 1 │ 2 │ 3 │ ← Ligne 0 → Somme: 6
├─────────────┼─────────────┼─────────────┤
│ 4 │ 5 │ 6 │ ← Ligne 1 → Somme: 15
├─────────────┼─────────────┼─────────────┤
│ 7 │ 8 │ 9 │ ← Ligne 2 → Somme: 24
└─────────────┴─────────────┴─────────────┘
Somme totale: 6 + 15 + 24 = 45
Créer une variable resultat initialisée à 0
Utiliser deux boucles imbriquées pour accéder à chaque élément
Additionner chaque élément à l'accumulateur
La fonction retourne la somme de tous les éléments de la matrice
• Initialisation : Toujours initialiser l'accumulateur à 0
• Parcours complet : Visiter tous les éléments de la matrice
• Accumulation : Ajouter chaque élément à l'accumulateur
Diagonales d'une matrice carrée : Diagonale principale (indices égaux) et diagonale secondaire (indices complémentaires).
│ 1* │ 2 │ 3# │ ← Diagonale principale: *
├─────────────┼─────────────┼─────────────┤
│ 4 │ 5* │ 6# │ Diagonale secondaire: #
├─────────────┼─────────────┼─────────────┤
│ 7# │ 8 │ 9* │
└─────────────┴─────────────┴─────────────┘
Diagonale principale: 1 + 5 + 9 = 15
Diagonale secondaire: 3 + 5 + 7 = 15 (moins le centre: 10)
Somme totale: 15 + 10 = 25
Sommer les éléments où ligne = colonne (mat[i][i])
Sommer les éléments où ligne + colonne = taille - 1 (mat[i][taille-1-i])
Pour les matrices impaires, soustraire l'élément central (compté deux fois)
Algorithmes qui calculent la somme des deux diagonales en O(n) opérations
• Diagonale principale : Indices égaux [i][i]
• Diagonale secondaire : [i][n-1-i] pour une matrice n×n
• Centre : Dans les matrices impaires, l'élément central est compté deux fois
Transposition : Opération qui transforme une matrice en échangeant ses lignes et ses colonnes (mat[i][j] devient mat[j][i]).
┌─────────────┬─────────────┬─────────────┐
│ 1 │ 2 │ 3 │
├─────────────┼─────────────┼─────────────┤
│ 4 │ 5 │ 6 │
├─────────────┼─────────────┼─────────────┤
│ 7 │ 8 │ 9 │
└─────────────┴─────────────┴─────────────┘
Après transposition:
┌─────────────┬─────────────┬─────────────┐
│ 1 │ 4 │ 7 │
├─────────────┼─────────────┼─────────────┤
│ 2 │ 5 │ 8 │
├─────────────┼─────────────┼─────────────┤
│ 3 │ 6 │ 9 │
└─────────────┴─────────────┴─────────────┘
mat[i][j] devient mat[j][i] pour tous i,j
Utiliser des boucles imbriquées pour accéder aux éléments
Ne traiter que les éléments au-dessus de la diagonale (j > i)
Échanger mat[i][j] avec mat[j][i] pour chaque paire
Matrice transposée en O(n²) opérations, avec optimisation pour éviter les doublons
• Échange : mat[i][j] ↔ mat[j][i] pour tous les couples
• Optimisation : Limiter le parcours à j > i pour éviter les doubles échanges
• Diagonale : Les éléments de la diagonale restent inchangés
