Le tableau suivant montre la complexité temporelle des opérations de base pour les tableaux.

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Array Time Complexities</title>
    <style>
        table {
            width: 80%;
            margin: 20px auto;
            border-collapse: collapse;
            border: 1px solid #ddd;
        }

        th,
        td {
            padding: 10px;
            text-align: left;
        }

        th {
            background-color: #f2f2f2;
        }

        tr:nth-child(even) {
            background-color: #f2f2f2;
        }

        tr:hover {
            background-color: #ddd;
        }

        th strong {
            font-weight: bold;
        }

        td strong {
            font-weight: bold;
        }
    </style>
</head>

<body>

    <table>
        <tr>
            <th><strong>Operation</strong></th>
            <th><strong>Best Case Time Complexity</strong></th>
            <th><strong>Worst Case Time Complexity</strong></th>
            <th><strong>Average Case Time Complexity</strong></th>
        </tr>
        <tr>
            <td><strong>Insert</strong></td>
            <td>O(1)</td>
            <td>O(n)</td>
            <td>O(n)</td>
        </tr>
        <tr>
            <td><strong>Delete</strong></td>
            <td>O(1)</td>
            <td>O(n)</td>
            <td>O(n)</td>
        </tr>
        <tr>
            <td><strong>Search</strong></td>
            <td>O(1)</td>
            <td>O(n)</td>
            <td>O(n)</td>
        </tr>
    </table>

</body>

</html>


## Opération de recherche
Comme nous l'avons discuté précédemment et comme cela peut être vu ci-dessus, l'avantage principal du tableau est que nous pouvons accéder à un élément arbitraire en **temps constant** si nous **connaissons l'index de cet élément dans un tableau**. Mais si nous ne savons pas quel élément nous recherchons, l'opération de recherche prend une complexité temporelle de `O(N)` car nous devons effectuer une recherche linéaire pour un élément.
```python
def search_array(arr, target):
    
    return np.any(arr == target)
```


## Opération de suppression
Si nous voulons supprimer un élément par index, nous pouvons le faire en temps constant.    
Cependant, parce que les tableaux sont représentés par des **blocs de mémoire continus**, supprimer un élément arbitraire (sauf pour le dernier élément) signifie que nous devons gérer des "trous" dans une structure de données. L'image suivante l'illustre.

Pour se débarrasser des trous, nous devons **déplacer tous les éléments** du "trou" jusqu'à la fin du tableau, une position plus près du début du tableau. Et dans le pire des cas, si nous supprimons le premier élément, nous devons déplacer tous les autres éléments, et la complexité temporelle de cette opération sera `O(N)`. Dans le meilleur des cas, nous aurons une complexité temporelle de `O(1)` lors de la suppression du dernier élément.

```python
def delete_element(arr, index):
   
    if index < 0 or index >= len(arr):
        print("Error: Index out of range.")
        return arr
    return np.delete(arr, index)
```    



## Opération d'insertion
Comme pour la suppression d'éléments, lors de l'insertion d'un élément dans un tableau, nous pouvons avoir besoin de **déplacer les éléments existants** pour faire de la place pour le nouvel élément. Dans le pire des cas, lors de l'insertion au **début** du tableau, nous devrions déplacer l'ensemble du tableau, ce qui entraîne une complexité temporelle de `O(n)`. Cependant, lors de l'insertion à la **fin** du tableau, nous pouvons simplement placer le nouvel élément sans aucun déplacement, ce qui entraîne une complexité temporelle de `O(1)`.

```python
def insert_element(array, index, value):

    # Check if the index is valid
    if index < 0 or index > len(array):
        raise IndexError("Index is out of bounds.")

    # Insert the value at the specified index using numpy.insert
    new_array = np.insert(array, index, value)

    return new_array
```

Quelle est la complexité temporelle pour insérer un élément au début et à la fin d'un tableau ?

La compréhension des structures de données et des algorithmes : c'est ce qui distingue les professionnels avancés des autres. Dans le monde moderne des données croissantes, il est très important de pouvoir traiter de grandes quantités de données efficacement. 

Dans ce cours, vous étudierez les structures de données les plus basiques qui nous aident à gérer d'énormes quantités de données ainsi qu'à implémenter les concepts les plus basiques et cruciaux par vous-même afin que vous obteniez une compréhension plus profonde de la façon dont chaque structure de données fonctionne et que vous puissiez décider quelle structure de données est la mieux adaptée à votre tâche.

Lorsque nous commençons à apprendre quelque chose de nouveau, il est très important de se familiariser d'abord avec le sujet de notre étude. Alors plongeons plus profondément dans ce que nous allons apprendre dans ce cours.

Les tableaux et les listes servent de structures de données fondamentales en programmation, avec une utilisation intensive en Python. Cette section offre un aperçu de ces structures, en explorant leurs concepts et en mettant en lumière leurs nuances d'implémentation dans le langage de programmation Python.

Il existe de nombreuses tâches appliquées dans lesquelles il est nécessaire de manipuler de grandes quantités de données structurées et des structures de données simples telles qu'un array ou une liste chaînée peuvent ne plus suffire à ces fins. Dans cette section, nous examinerons le concept de type de données abstrait et comment différents ADT nous permettent de gérer efficacement de grandes quantités de données.

Dans le monde réel, on doit souvent faire face à des tâches où il est nécessaire de modéliser des dépendances complexes entre divers nœuds d'un système ou d'un domaine. Les graphes peuvent nous aider à cela. Dans cette section, nous apprendrons ce qu'est un graphe et comment le représenter efficacement en mémoire informatique.

Aperçu des Algorithmes et des Structures de Données

Complexité Temporelle des Opérations de Base sur les Tableaux

Opération de recherche

Opération de suppression

Opération d'insertion