Qu'est-ce qu'un tableau ?

• Un tableau est une collection d'éléments, chacun identifié par un index ou une clé.
• Les tableaux ont une taille fixe et dynamique
• Éléments homogènes → tous les éléments d'un tableau sont du même type de données.
• Éléments hétérogènes → permettant différents types de données dans le même tableau.

// Homogeneous 
int[] intArray = new int[5]; // Array of integers String[] 
stringArray = new String[5]; // Array of strings

// Heterogeneous
mixedArray = [1, "hello", 3.14, True]  # Mixed data types in one list

Caractéristiques des tableaux

• Indexation : indexation de base zéro dans la plupart des langages de programmation.
• Taille : taille fixe (statique), ne peut pas être modifiée dynamiquement (sauf dans les langages avec des tableaux dynamiques).
• Allocation de mémoire : allocation de mémoire contiguë pour les éléments du tableau. ce qui signifie que chaque élément est directement à côté du précédent en mémoire. Ceci est possible car tous les éléments ont la même taille, ce qui permet au système de calculer l'adresse mémoire de n'importe quel élément en utilisant son index.

Opérations sur les tableaux

• Insertion : implique généralement le déplacement d'éléments, une complexité temporelle O(n).
• Suppression : comme pour l'insertion, les éléments peuvent devoir être déplacés. Sauf dernier index
• Traversal : itération à travers tous les éléments, complexité temporelle O(n).
• Temps d'accès : complexité temporelle O(1) pour accéder à un élément à l'aide de son index.

Types de tableaux

• Tableau unidimensionnel : forme la plus simple, comme une liste.
• Tableau multidimensionnel : tableaux de tableaux (par exemple, tableau 2D).
• Matrice jagged : tableaux avec différentes longueurs de sous-tableaux.
• Tableaux dynamiques (par exemple, ArrayList en Java) : tableaux dont la taille peut croître de manière dynamique.

Avantages des tableaux

• Efficacité : O(1) temps d'accès aux éléments.
• Utilisation de la mémoire : utilisation efficace de la mémoire grâce au stockage contigu.
• Facilité d'utilisation : simplifie la gestion des données et les opérations telles que le tri et la recherche

Inconvénients des tableaux

• Taille fixe : Impossible de modifier la taille une fois déclarée. sauf tableau dynamique
• Coût d'insertion/suppression : O(n) pour insérer ou supprimer un élément, notamment au milieu.
• Perte de mémoire : les éléments inutilisés occupent toujours de l'espace.

Applications réelles des tableaux

• Stockage de données : courant dans la programmation pour stocker des collections d'éléments.
• Algorithmes de tri : de nombreux algorithmes de tri sont conçus pour les tableaux (par exemple, QuickSort, MergeSort).
• Opérations matricielles : les tableaux 2D sont utilisés pour les opérations matricielles en mathématiques et en graphiques.
• Implémentation de piles et de files d'attente : les structures de données de base peuvent être implémentées à l'aide de tableaux.

Meilleures pratiques avec les tableaux

• Évitez les copies inutiles : soyez attentif aux opérations qui nécessitent la copie d'éléments.
• Utilisez des tableaux dynamiques si nécessaire : si la taille est incertaine, préférez les tableaux dynamiques.
• Exploitez les fonctions intégrées : utilisez des fonctions spécifiques au langage pour les opérations sur les tableaux.
• Vérification des limites : vérifiez toujours les conditions aux limites pour éviter l'exception IndexOutOfBoundsException.

Exemple de tableau statique et dynamique dans GO

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // Static Array
    var staticArr [5]int64
    staticArr[0] = 1
    staticArr[1] = 2
    staticArr[2] = 3
    staticArr[3] = 4
    staticArr[4] = 5
    elementSize := unsafe.Sizeof(staticArr[0])
    totalSize := elementSize * uintptr(len(staticArr))
    fmt.Printf("Memory used by static array: %d bytes\n", totalSize)
    fmt.Println()

    // Dynamic Array (Slice)
    dynamicArr := make([]int32, 0, 5)
    before := unsafe.Sizeof(dynamicArr[0])
    beforeTotal := before * uintptr(len(dynamicArr))
    fmt.Printf("Memory used by dynamic array (before): %d bytes\n", beforeTotal)

    // Append elements to dynamic array
    for i := 0; i