Tableau bidimensionnel en C

Structure et allocation de la mémoire

Il est essentiel de comprendre la structure et l'allocation de mémoire d'un tableau 2D pour pouvoir travailler efficacement avec cette structure de données. Lors de la déclaration d'un tableau 2D, tu dois spécifier le nombre de lignes et de colonnes à l'aide de la syntaxe suivante :

    data_type nom_de_tableau[taille_de_ligne][taille_de_colonne] ; 

Par exemple, le code suivant déclare un tableau 2D d'entiers avec 3 lignes et 4 colonnes :

    int matrix[3][4] ; 

L'allocation de mémoire pour un tableau 2D est contiguë, ce qui signifie qu'il est stocké dans des emplacements de mémoire consécutifs. La disposition du tableau 2D dans la mémoire dépend de l'ordre utilisé, qui peut être majeur en ligne ou majeur en colonne.

Ordre ligne-major et colonne-major

L'ordre ligne-major et l'ordre colonne-major sont deux façons courantes de représenter les tableaux 2D en mémoire. Le choix de l'une ou l'autre dépend des exigences spécifiques de ton programme.

Par défaut, le langage C utilise l'ordre ligne-major lors de l'allocation de mémoire pour les tableaux 2D. Pour illustrer cela, considère le tableau 3x3 suivant :

    int arr[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} } ; 

Dans l'ordre des rangs majeurs, la mémoire de ce tableau 2D serait allouée comme suit :

    1, 2, 3, 4, 5, 6, 7, 8, 9 

Ici, tu peux voir que chaque ligne est stockée sous forme de bloc contigu, et que le premier élément de chaque ligne suivante suit immédiatement le dernier élément de la ligne précédente.

      1, 4, 7, 2, 5, 8, 3, 6, 9 

Il est important de noter que l'ordre majeur de ligne est plus couramment utilisé dans la programmation C, car c'est la méthode par défaut. Cependant, il peut être utile de comprendre l'ordre majeur des colonnes pour travailler avec d'autres langages de programmation ou d'autres bibliothèques qui peuvent utiliser l'ordre majeur des colonnes.

Exemples pratiques de tableaux 2D en C

Dans cette section, nous allons nous plonger dans des exemples pratiques d'utilisation de tableaux 2D en programmation C pour résoudre divers problèmes. Ces exemples t'aideront à comprendre comment travailler efficacement avec des tableaux 2D et à appliquer tes compétences dans des situations réelles.

Exemple de tableau 2D en C : Multiplication de matrice

La multiplication des matrices est une opération courante en algèbre linéaire et dans les applications informatiques. Voyons comment mettre en œuvre la multiplication matricielle à l'aide de tableaux 2D en C. Supposons que nous ayons deux matrices A et B, où A a des dimensions m×n et B des dimensions n×p. La matrice produit C aura des dimensions m×p.

La formule de multiplication des matrices est la suivante :

Voici un guide étape par étape pour mettre en œuvre la multiplication matricielle à l'aide de tableaux 2D en C :

Voici un exemple de code pour démontrer la multiplication de matrices à l'aide de tableaux 2D :

#includeint main() { int m = 3, n = 3, p = 3 ; int A[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} ;

    int B[3][3] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}} ; int C[3][3] ; for (int i = 0 ; i < m ; ++i) { for (int j = 0 ; j < p ; ++j) { int sum = 0 ; for (int k = 0 ; k < n ; ++k) { sum += A[i][k] * B[k][j] ; } C[i][j] = sum ; } } for (int i = 0 ; i < m ; ++i) { for (int j = 0 ; j < p ; ++j) { printf("%d\t", C[i][j]) ; } printf("\n") ; } return 0 ; } 

Tableau 2D en C avec des pointeurs : Allocation dynamique de la mémoire

L'allocation dynamique de la mémoire est une fonction essentielle lorsque l'on travaille avec des tableaux 2D en C, car elle permet de créer des tableaux dont la taille est déterminée au moment de l'exécution. Pour effectuer une allocation dynamique de la mémoire, tu peux combiner les pointeurs avec la fonction malloc, qui alloue un bloc de mémoire de la taille spécifiée en octets et renvoie un pointeur sur cette mémoire.

Pour allouer de la mémoire, utilise la syntaxe suivante :

type** nom_du_tableau = (type**)malloc(sizeof(type*) * row_size) ; 

Voyons un guide étape par étape pour allouer et désallouer la mémoire d'un tableau 2D en C :

Voici un exemple de code pour démontrer l'allocation dynamique de la mémoire avec des tableaux 2D utilisant des pointeurs en C :

#include#includeint main() { int row_size = 3, column_size = 3 ; int** array = (int**)malloc(sizeof(int*) * row_size) ; for (int i = 0 ; i < row_size ; ++i) { array[i] = (int*)malloc(sizeof(int) * column_size) ; } for (int i = 0 ; i < row_size ; ++i) { for (int j = 0 ; j < column_size ; ++j) { array[i][j] = i * j ; } } for (int i = 0 ; i < row_size ; ++i) { for (int j = 0 ; j < column_size ; ++j) { printf("%d\t", array[i][j]) ; } printf("\n") ; } for (int i = 0 ; i < row_size ; ++i) { free(array[i]) ; } free(array) ; return 0 ; } 

Ce code montre comment allouer de la mémoire à un tableau 2D à l'aide de pointeurs et de la fonction malloc, puis comment libérer la mémoire après avoir effectué les calculs nécessaires à l'aide de la fonction free.

Opérations supplémentaires avec un tableau 2D en C

Tableau 2D en C Addition : Addition de deux matrices

L'addition de matrices est une autre opération courante en programmation informatique et en algèbre linéaire. Le processus d'addition de deux matrices consiste à ajouter les éléments correspondants de chaque matrice pour créer une nouvelle matrice ayant les mêmes dimensions. Voyons comment mettre en œuvre l'addition de matrices à l'aide de tableaux 2D en C.

Supposons que nous ayons deux matrices A et B de dimensions m×n. La matrice C résultant de l'addition des deux matrices aura également des dimensions m×n. L'opération peut être représentée mathématiquement comme suit :

Voici un guide étape par étape pour mettre en œuvre l'addition de matrices à l'aide de tableaux 2D en C :

1. Déclare et initialise les matrices A et B, ainsi que leurs dimensions (m, n) conformément aux exigences du problème.

2. Déclare la matrice C de dimensions m×n pour stocker le résultat de l'addition.

3. Boucle sur chaque élément de la matrice A en utilisant une variable i ∈ [0, m - 1] et boucle sur chaque élément de la matrice B en utilisant une variable j ∈ [0, n - 1].

4. Pour chaque combinaison de i et j, calcule la somme c[i][j] = a[i][j] + b[i][j].

5. Donne le résultat de la matrice C.

Voici un exemple de code pour démontrer l'addition de matrices à l'aide de tableaux 2D :

#includeint main() { int m = 3, n = 3 ; int A[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}} ; int B[3][3] = {{9, 8, 7}, {6, 5, 4}, {3, 2, 1}} ; int C[3][3] ; for (int i = 0 ; i < m ;++i) { for (int j = 0 ; j < n ; ++j) { C[i][j] = A[i][j] + B[i][j] ; } } for (int i = 0 ; i < m ; ++i) { for (int j = 0 ; j < n ; ++j) { printf("%d\t", C[i][j]) ; } printf("\n") ; } return 0 ; } 

Tableau 2D en C expliqué : Techniques de recherche et de tri

La recherche et le tri sont des opérations fondamentales qui peuvent être appliquées aux tableaux 2D en C. La compréhension de ces techniques peut t'aider à améliorer l'efficacité de ton programme lorsque tu manipules de grands ensembles de données. Dans cette section, nous aborderons deux types de techniques de recherche (recherche linéaire et recherche binaire) et une technique de tri (tri par sélection) qui peuvent être appliquées aux tableaux 2D en C.

Recherche linéaire dans un tableau 2D

La recherche linéaire est une technique de recherche qui itère sur chaque élément du tableau 2D jusqu'à ce que l'élément souhaité soit trouvé ou que le tableau soit entièrement parcouru. L'algorithme peut être mis en œuvre à l'aide de boucles imbriquées, ce qui nous permet d'accéder à chaque élément du tableau 2D.

Voici un guide étape par étape pour mettre en œuvre la recherche linéaire dans un tableau 2D :

Recherche binaire dans un tableau 2D

La recherche binaire est une technique de recherche plus efficace pour les tableaux triés. Elle consiste à diviser plusieurs fois l'intervalle de recherche en deux. Lorsque tu travailles avec des tableaux en 2D, tu peux utiliser la recherche binaire sur une ligne ou une colonne triée. Voici la mise en œuvre de la recherche binaire dans un tableau 2D trié par ligne :

Tri par sélection dans un tableau 2D

Le tri par sélection est une technique de tri simple qui fonctionne en sélectionnant de façon répétée l'élément minimum dans la partie non triée du tableau. Voici un guide étape par étape pour mettre en œuvre le tri par sélection sur un tableau 2D :

L'algorithme de tri par sélection peut être facilement adapté pour trier les colonnes d'un tableau 2D au lieu des lignes en échangeant les variables de la boucle.

Déclaration d'un tableau 2D en C : Différentes méthodes et syntaxes

Plusieurs méthodes et syntaxes peuvent être utilisées pour déclarer et initialiser des tableaux 2D en C. Chaque méthode a un but particulier et offre différents niveaux de contrôle et de flexibilité lorsque l'on travaille avec des tableaux 2D. Examinons quelques méthodes courantes :

data_type nom_du_tableau[taille_de_la_rangée][taille_de_la_colonne] ; 

. 

Déclare un tableau 2D de taille fixe et initialise ses éléments.

data_type nom_du_tableau[taille_de_ligne][taille_de_colonne] = { {élément1, élémentm2, élément3}, {élément4, élément5, élément6}, ... 

; 

. 

int row_size = ... ; int column_size = ... ; data_type nom_du_tableau[row_size][column_size] ; 

. 

Chacune de ces méthodes a ses avantages et ses limites. L'allocation statique est simple et facile à utiliser, mais elle ne permet pas de modifier la taille du tableau pendant l'exécution. Les tableaux de longueur variable (VLA) offrent un certain niveau de flexibilité lors de l'exécution mais ne sont pas disponibles dans tous les compilateurs C. L'allocation dynamique de la mémoire à l'aide de pointeurs offre la plus grande flexibilité et le meilleur contrôle, mais nécessite de gérer manuellement l'allocation et la désallocation de la mémoire.

Le choix de la méthode appropriée pour déclarer et initialiser les tableaux 2D en C dépend de tes besoins et contraintes de programmation spécifiques. Chaque méthode offre un équilibre unique entre simplicité, flexibilité et contrôle, ce qui la rend adaptée à différentes situations.