Die folgende Tabelle zeigt die Zeitkomplexität grundlegender Operationen für Arrays.

<!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>


## Suchoperation
Wie wir bereits besprochen haben und wie oben zu sehen ist, besteht der Hauptvorteil des Arrays darin, dass wir auf ein beliebiges Element in **konstanter Zeit** zugreifen können, wenn wir **den Index dieses Elements im Array kennen**. Aber wenn wir nicht wissen, nach welchem Element wir suchen, hat die Suchoperation eine Zeitkomplexität von `O(N)`, da wir eine lineare Suche nach einem Element durchführen müssen.
```python
def search_array(arr, target):
    
    return np.any(arr == target)
```


## Löschoperation
Wenn wir ein Element nach Index löschen möchten, können wir dies in konstanter Zeit tun.    
Da Arrays jedoch mit **kontinuierlichen Speicherblöcken** dargestellt werden, bedeutet das Entfernen eines beliebigen Elements (außer dem letzten Element), dass wir mit "Löchern" in einer Datenstruktur umgehen müssen. Das nächste Bild veranschaulicht dies.

Um Löcher loszuwerden, müssen wir **alle Elemente verschieben** vom "Loch" bis zum Ende des Arrays, eine Position näher zum Anfang des Arrays. Und im schlimmsten Fall, wenn wir das erste Element entfernen, müssen wir alle anderen Elemente verschieben, und die Zeitkomplexität dieser Operation wird `O(N)` sein. Im besten Fall haben wir eine Zeitkomplexität von `O(1)`, wenn wir das letzte Element entfernen.

```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)
```    



## Einfügeoperation
Wie beim Löschen von Elementen müssen wir beim Einfügen eines Elements in ein Array möglicherweise **vorhandene Elemente verschieben**, um Platz für das neue Element zu schaffen. Im schlimmsten Fall, wenn wir am **Anfang** des Arrays einfügen, müssten wir das gesamte Array verschieben, was zu einer Zeitkomplexität von `O(n)` führt. Wenn wir jedoch am **Ende** des Arrays einfügen, können wir das neue Element einfach ohne Verschiebung platzieren, was zu einer Zeitkomplexität von `O(1)` führt.

```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
```

Wie lautet die Zeitkomplexität für das Einfügen eines Elements am Anfang und am Ende eines Arrays?

Das Verständnis von Datenstrukturen und Algorithmen: Dies ist es, was fortgeschrittene Fachleute von den anderen unterscheidet. In der modernen Welt wachsender Daten ist es sehr wichtig, große Datenmengen effizient verarbeiten zu können.

In diesem Kurs werden Sie die grundlegendsten Datenstrukturen studieren, die uns helfen, mit großen Datenmengen umzugehen, sowie die grundlegendsten und entscheidenden Konzepte selbst implementieren, damit Sie ein tieferes Verständnis dafür bekommen, wie jede Datenstruktur funktioniert und Sie in der Lage sein werden, zu entscheiden, welche Datenstruktur am besten für Ihre Aufgabe geeignet ist.

Wenn wir etwas Neues lernen, ist es sehr wichtig, sich zuerst mit dem Thema unserer Studie vertraut zu machen. Also lassen Sie uns tiefer eintauchen, was wir in diesem Kurs lernen werden.

Arrays und Listen dienen als grundlegende Datenstrukturen in der Programmierung, wobei Python sie umfassend einsetzt. Dieser Abschnitt bietet einen Überblick über diese Strukturen, geht auf ihre Konzepte ein und hebt ihre Implementierungsnuancen innerhalb der Programmiersprache Python hervor.

Es gibt viele angewandte Aufgaben, bei denen es notwendig ist, mit großen Mengen an strukturierten Daten zu arbeiten, und einfache Datenstrukturen wie ein Array oder eine verkettete Liste möglicherweise nicht mehr ausreichen. In diesem Abschnitt betrachten wir das Konzept eines abstrakten Datentyps und wie verschiedene ADTs es uns ermöglichen, große Datenmengen effizient zu verwalten.

In der realen Welt muss man oft Aufgaben bewältigen, bei denen es notwendig ist, komplexe Abhängigkeiten zwischen verschiedenen Knoten eines Systems oder einer Domäne zu modellieren. Graphen können uns dabei helfen. In diesem Abschnitt werden wir lernen, was ein Graph ist und wie man ihn effizient im Computerspeicher darstellt.

Überblick Über Algorithmen und Datenstrukturen

Zeitkomplexität Grundlegender Array-Operationen

Suchoperation

Löschoperation

Einfügeoperation