Prérequis: Tableaux en C

Un tableau multidimensionnel peut être qualifié de tableau de tableaux qui stocke des données homogènes sous forme de tableau. Les données des tableaux multidimensionnels sont généralement stockées dans l’ordre des lignes principales dans la mémoire.

Le forme générale de déclaration de tableaux à N dimensions est montré ci-dessous.

Syntaxe:

data_type array_name[size1][size2]....[sizeN];>

• Type de données : Type de données à stocker dans le tableau.
• nom_tableau : Nom du tableau.
• taille1, taille2,…, tailleN : Taille de chaque dimension.

Exemples :

chaîne convertie en int en java

  Two dimensional array:   int two_d[10][20];   Three dimensional array:   int three_d[10][20][30];>

Taille des tableaux multidimensionnels :

Le nombre total d'éléments pouvant être stockés dans un tableau multidimensionnel peut être calculé en multipliant la taille de toutes les dimensions.
Par exemple:

• Le tableau entier x[10][20] peut stocker un total (10*20) = 200 éléments.
• De même, tableau int x[5][10][20] peut stocker un total (5*10*20) = 1000 éléments.

Pour obtenir la taille du tableau en octets, nous multiplions la taille d’un seul élément par le nombre total d’éléments du tableau.
Par exemple:

• Taille du tableau entier x[10][20] = 10 * 20 * 4 = 800 octets. (où int = 4 octets)
• De même, la taille de int x[5][10][20] = 5 * 10 * 20 * 4 = 4000 octets. (où int = 4 octets)

Les formes les plus couramment utilisées du tableau multidimensionnel sont :

1. Tableau bidimensionnel
2. Tableau tridimensionnel

Tableau bidimensionnel en C

UN tableau bidimensionnel ou tableau 2D en C est la forme la plus simple du tableau multidimensionnel. Nous pouvons visualiser un tableau bidimensionnel comme un tableau de tableaux unidimensionnels disposés les uns sur les autres formant un tableau avec des lignes « x » et des colonnes « y » où le numéro de ligne va de 0 à (x-1) et le numéro de colonne. va de 0 à (y-1).

Représentation graphique d'un tableau bidimensionnel de taille 3 x 3

Déclaration d'un tableau bidimensionnel en C

La forme de base de déclaration d'un tableau 2D avec X lignes et et Les colonnes en C sont illustrées ci-dessous.

Syntaxe:

data_type array_name[x][y];>

où,

• Type de données: Type de données à stocker dans chaque élément.
• nom_du tableau : nom du tableau
• X: Nombre de rangées.
• et: Le nombre de colonnes.

Nous pouvons déclarer un tableau d’entiers bidimensionnels, disons « x », avec 10 lignes et 20 colonnes comme :

Exemple:

int x[10][20];>

Remarque : dans ce type de déclaration, le tableau se voit allouer de la mémoire dans la pile et la taille du tableau doit être connue au moment de la compilation, c'est-à-dire que la taille du tableau est fixe. Nous pouvons également créer dynamiquement un tableau en C en utilisant les méthodes mentionnées ici.

Initialisation de tableaux bidimensionnels en C

Les différentes manières d'initialiser un tableau 2D sont les suivantes :

1. Utilisation de la liste d'initialisation
2. Utiliser des boucles

1. Initialisation du tableau 2D à l'aide de la liste d'initialisation

Nous pouvons initialiser un tableau 2D en C en utilisant une liste d'initialisation comme le montre l'exemple ci-dessous.

Première méthode :

int x[3][4] = {0, 1 ,2 ,3 ,4 , 5 , 6 , 7 , 8 , 9 , 10 , 11}>

Le tableau ci-dessus comporte 3 lignes et 4 colonnes. Les éléments entre accolades de gauche à droite sont également stockés dans le tableau de gauche à droite. Les éléments seront remplis dans le tableau dans l'ordre : les 4 premiers éléments en partant de la gauche seront remplis dans la première ligne, les 4 éléments suivants dans la deuxième ligne, et ainsi de suite.

Deuxième méthode (meilleure) :

int x[3][4] = {{0,1,2,3}, {4,5,6,7}, {8,9,10,11}};>

Ce type d'initialisation utilise des accolades imbriquées. Chaque ensemble d'accolades intérieures représente une ligne. Dans l’exemple ci-dessus, il y a un total de trois rangées, donc trois jeux d’accolades intérieures. L’avantage de cette méthode est qu’elle est plus facile à comprendre.

Remarque : Le nombre d'éléments dans la liste d'initialisation doit toujours être inférieur ou égal au nombre total d'éléments dans le tableau.

Nous pouvons également déclarer le tableau sans définir la taille de la ligne si nous utilisons l'initialisation de liste. Le compilateur déduira automatiquement la taille du tableau dans ce cas :

data_type array_name[][y] = {...} ;>

Il reste obligatoire de définir le nombre de colonnes.

2. Initialisation du tableau 2D à l'aide de boucles

Nous pouvons utiliser n'importe quelle boucle C pour initialiser chaque membre d'un tableau 2D un par un, comme le montre l'exemple ci-dessous.

Exemple:

int x[3][4]; for(int i = 0; i <3; i++){ for(int j = 0; j < 4; j++){ x[i][j] = i + j; } }>

Cette méthode est utile lorsque les valeurs de chaque élément ont une relation séquentielle.

Accéder aux éléments des tableaux bidimensionnels en C

Les éléments des tableaux 2D sont accessibles à l’aide des index de ligne et des index de colonne. Chaque élément d'un tableau 2D peut être référencé par :

Syntaxe:

array_name[i][j]>

où,

• je: L'index de ligne.
• j: L'index de la colonne.

Exemple:

int x[2][1];>

L'exemple ci-dessus représente l'élément présent dans la troisième ligne et la deuxième colonne.

objet java en json

Note : Dans les tableaux, si la taille d'un tableau est N. Son index sera de 0 à N-1. Par conséquent, pour l'index de ligne 2, le numéro de ligne est 2+1 = 3. Pour afficher tous les éléments d'un tableau bidimensionnel, nous pouvons utiliser des boucles for imbriquées. Nous aurons besoin de deux ‘ pour ' boucles. Un pour parcourir les lignes et un autre pour parcourir les colonnes.

Pour imprimer l'ensemble du tableau, nous accédons à chaque élément un par un à l'aide de boucles. L'ordre de parcours peut être un ordre de ligne principale ou un ordre de colonne principale en fonction des besoins. L'exemple ci-dessous montre le parcours des lignes principales d'un tableau 2D.

Exemple:

C

>

>

Element at x[0][0]: 0 Element at x[0][1]: 1 Element at x[1][0]: 2 Element at x[1][1]: 3 Element at x[2][0]: 4 Element at x[2][1]: 5>

Complexité temporelle : O(N*M) , où N(ici 3) et M(ici 2) sont respectivement des nombres de lignes et de colonnes.

Complexité spatiale : O(1)

Comment les tableaux 2D sont-ils stockés dans la mémoire ?

Les éléments du tableau 2D doivent être stockés de manière contiguë en mémoire. Les ordinateurs ayant des adresses mémoire linéaires, les tableaux 2D doivent être linéarisés afin de permettre leur stockage. Il existe deux manières de réaliser la linéarisation des éléments d'un tableau :

• Rangée-majeure- La technique de linéarisation stocke d'abord la première ligne du tableau, puis la deuxième ligne du tableau, puis la troisième ligne, et ainsi de suite. (c'est-à-dire que les éléments sont stockés par ligne. Les lignes sont répertoriées sur la base des colonnes)
• Colonne majeure – Cette technique de linéarisation stocke d'abord la première colonne, puis la deuxième colonne, puis la troisième colonne, et ainsi de suite, c'est-à-dire (les éléments sont stockés par colonne. Les colonnes sont répertoriées sur la base des lignes)

L'ordinateur ne garde pas la trace des adresses de tous les éléments du tableau mais garde la trace de l'adresse de base (adresse de départ du tout premier élément) et calcule les adresses des éléments lorsque cela est nécessaire.

Pour en savoir plus, référez-vous à l’article – Calcul de l'adresse de l'élément de 1-D, 2-D et 3-D

Tableau tridimensionnel en C

UN Tableau tridimensionnel ou 3D array en C est une collection de tableaux à deux dimensions. Il peut être visualisé sous la forme de plusieurs tableaux 2D empilés les uns sur les autres.

Représentation graphique d'un tableau tridimensionnel de taille 3 x 3 x 3

Déclaration d'un tableau tridimensionnel en C

On peut déclarer un tableau 3D avec X Tableaux 2D ayant chacun et lignes et Avec colonnes en utilisant la syntaxe indiquée ci-dessous.

Syntaxe:

data_type array_name[x][y][z];>

• Type de données: Type de données à stocker dans chaque élément.
• nom_du tableau : nom du tableau
• X: Nombre de tableaux 2D.
• et: Nombre de lignes dans chaque tableau 2D.
• Avec: Nombre de colonnes dans chaque tableau 2D.

Exemple:

int array[3][3][3];>

Initialisation du tableau tridimensionnel en C

L'initialisation dans un tableau 3D est la même que celle des tableaux 2D. La différence est que plus le nombre de dimensions augmente, plus le nombre d'accolades imbriquées augmente également.

Un tableau 3D en C peut être initialisé en utilisant :

1. Liste d'initialisation
2. Boucles

Initialisation du tableau 3D à l'aide de la liste d'initialisation

Méthode 1 :

int x[2][3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23};>

Méthode 2 (mieux) :

int x[2][3][4] =   {   { {0,1,2,3}, {4,5,6,7}, {8,9,10,11} },  { {12,13,14,15}, {16,17,18,19}, {20,21,22,23} }  };>

Encore une fois, tout comme les tableaux 2D, nous pouvons également déclarer les tableaux 3D sans spécifier la taille des premières dimensions si nous utilisons la liste d'initialisation pour l'initialisation. Le compilateur déduira automatiquement la taille de la première dimension. Mais il reste encore à préciser le reste des dimensions.

data_type array_name[][y][z] = {....};>

Initialisation d'un tableau 3D à l'aide de boucles

Il est également similaire à celui d'un tableau 2D avec une boucle imbriquée supplémentaire pour accéder à une dimension supplémentaire.

int x[2][3][4]; for (int i=0; i<2; i++) { for (int j=0; j<3; j++) { for (int k=0; k<4; k++) { x[i][j][k] = (some_value); } } }>

Accéder aux éléments dans un tableau tridimensionnel en C

L'accès aux éléments dans les tableaux 3D est également similaire à celui des tableaux 2D. La différence est que nous devons utiliser trois boucles au lieu de deux boucles pour une dimension supplémentaire dans les tableaux 3D.

Syntaxe:

array_name[x][y][z]>

où,

• X: Index du tableau 2D.
• et: Index de cette ligne de tableau 2D.
• Avec: Index de cette colonne du tableau 2D.

C

>

>

méthodes abstraites

Element at x[0][0][0] = 0 Element at x[0][0][1] = 1 Element at x[0][1][0] = 2 Element at x[0][1][1] = 3 Element at x[0][2][0] = 4 Element at x[0][2][1] = 5 Element at x[1][0][0] = 6 Element at x[1][0][1] = 7 Element at x[1][1][0] = 8 Element at x[1][1][1] = 9 Element at x[1][2][0] = 10 Element at x[1][2][1] = 11>

De la même manière, nous pouvons créer des tableaux avec n’importe quel nombre de dimensions. Cependant, la complexité augmente également à mesure que le nombre de dimensions augmente. Le tableau multidimensionnel le plus utilisé est le tableau bidimensionnel.

Les tableaux sont également étroitement liés aux pointeurs en langage C. Pour en savoir plus sur la relation entre les tableaux et les pointeurs en C, reportez-vous à ce article.