Arrays in C verarbeiten

CCBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie Arrays in der C-Programmierung verarbeiten. Das Lab behandelt die grundlegenden Konzepte der Array-Deklaration, -Initialisierung, -Zugriff und -Iteration. Sie beginnen mit der Einführung der Syntax zur Array-Deklaration, gehen dann zur Initialisierung eines Integer-Arrays mit Werten über, greifen auf Array-Elemente über Indizes zu und geben schließlich die Elemente in einer for-Schleife aus. Am Ende dieses Labs werden Sie ein solides Verständnis für die Arbeit mit Arrays in C haben.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL c(("C")) -.-> c/ControlFlowGroup(["Control Flow"]) c(("C")) -.-> c/CompoundTypesGroup(["Compound Types"]) c(("C")) -.-> c/UserInteractionGroup(["User Interaction"]) c(("C")) -.-> c/BasicsGroup(["Basics"]) c/BasicsGroup -.-> c/variables("Variables") c/BasicsGroup -.-> c/data_types("Data Types") c/ControlFlowGroup -.-> c/for_loop("For Loop") c/CompoundTypesGroup -.-> c/arrays("Arrays") c/UserInteractionGroup -.-> c/output("Output") subgraph Lab Skills c/variables -.-> lab-438330{{"Arrays in C verarbeiten"}} c/data_types -.-> lab-438330{{"Arrays in C verarbeiten"}} c/for_loop -.-> lab-438330{{"Arrays in C verarbeiten"}} c/arrays -.-> lab-438330{{"Arrays in C verarbeiten"}} c/output -.-> lab-438330{{"Arrays in C verarbeiten"}} end

Einführung in die Array-Deklarationssyntax

In diesem Schritt führen wir das grundlegende Konzept der Array-Deklaration in der C-Programmierung ein. Arrays sind essentielle Datenstrukturen, die es Ihnen ermöglichen, mehrere Elemente desselben Typs an einem zusammenhängenden Speicherort zu speichern. Stellen Sie sich ein Array wie eine Reihe von Lagerkästen vor, wobei jeder Kasten einen bestimmten Typ von Gegenstand aufnehmen kann und Sie diese Kästen über ihre eindeutige Indexnummer zugreifen können.

Was ist ein Array?

Ein Array ist eine Sammlung von Variablen, auf die über eine Indexnummer zugegriffen wird. Alle Elemente in einem Array sind vom gleichen Typ. Stellen Sie sich ein Bücherregal vor, auf dem jedes Fach Bücher desselben Genres aufnehmen kann – dies ähnelt der Funktionsweise eines Arrays in der Programmierung. Jedes "Buch" (oder Element) kann über seine Position (Index) auf dem Regal zugegriffen werden.

Array-Deklarationssyntax

Um ein Array in C zu deklarieren, verwenden Sie die folgende Syntax:

type arrayName[arraySize];
  • type: Der Datentyp der Elemente im Array (z. B. int, float, char). Dies bestimmt, welche Art von Daten das Array speichern kann.
  • arrayName: Der Name des Arrays, den Sie verwenden, um auf das Array zu verweisen und es zu manipulieren.
  • arraySize: Die Anzahl der Elemente, die das Array aufnehmen kann, definiert die gesamte Speicherkapazität des Arrays.

Beispiel: Deklarieren und Initialisieren eines Arrays

Beginnen wir damit, eine neue Datei in der WebIDE zu erstellen, um die Array-Deklaration zu untersuchen. Dieses praktische Beispiel wird Ihnen helfen, zu verstehen, wie Arrays in realen Programmier-Szenarien funktionieren.

Öffnen Sie die WebIDE und folgen Sie diesen Schritten:

  1. Klicken Sie mit der rechten Maustaste im Dateiexplorer und wählen Sie "Neue Datei".
  2. Benennen Sie die Datei arrays_intro.c.
  3. Klicken Sie auf die Datei, um sie im Editor zu öffnen.

Nun schreiben wir ein einfaches Programm, um die Array-Deklaration und -Initialisierung zu demonstrieren:

#include <stdio.h>

int main() {
    // Declaring an integer array with 5 elements
    int numbers[5] = {10, 20, 30, 40, 50};

    // Printing array elements
    printf("Array elements:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

Lassen Sie uns die Array-Deklaration analysieren:

  • int numbers[5]: Dies deklariert ein Integer-Array namens numbers, das 5 Elemente aufnehmen kann. Es ist wie das Erstellen eines Regals mit 5 Plätzen für die Speicherung von ganzzahligen Werten.
  • {10, 20, 30, 40, 50}: Dies initialisiert das Array mit bestimmten Werten und füllt jeden "Regalplatz" mit einer vordefinierten Zahl.
  • Das erste Element numbers[0] ist 10, das zweite numbers[1] ist 20 und so weiter. Denken Sie daran, dass die Array-Indizierung in C bei 0 beginnt.

Kompilieren und ausführen Sie das Programm:

Um das Programm zu kompilieren und auszuführen, verwenden Sie die folgenden Befehle im Terminal:

gcc arrays_intro.c -o arrays_intro
./arrays_intro

Beispielausgabe:

Array elements:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Diese Ausgabe zeigt, wie auf jedes Element im Array über seinen Index zugegriffen und ausgegeben werden kann. Das Verständnis dieses grundlegenden Konzepts ist der erste Schritt auf dem Weg zur Beherrschung der Array-Manipulation in der C-Programmierung.

Initialisieren eines Integer-Arrays mit Werten

In diesem Schritt werden wir verschiedene Methoden zur Initialisierung von Integer-Arrays in der C-Programmierung untersuchen. Das Verständnis der Array-Initialisierung ist entscheidend für die effektive Arbeit mit Datensammlungen.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei:

  1. Klicken Sie mit der rechten Maustaste im Dateiexplorer und wählen Sie "Neue Datei".
  2. Benennen Sie die Datei array_initialization.c.
  3. Klicken Sie auf die Datei, um sie im Editor zu öffnen.

Wenn Sie mit Arrays in C arbeiten, werden Sie schnell feststellen, dass es mehrere Ansätze zur Initialisierung gibt. Jede Methode hat ihren eigenen Anwendungsfall und kann Ihnen helfen, Ihre Datenspeicherung effizient einzurichten. Lassen Sie uns diese Initialisierungstechniken näher betrachten und verstehen, wie sie funktionieren:

#include <stdio.h>

int main() {
    // Method 1: Full initialization
    int scores[5] = {85, 92, 78, 90, 88};

    // Method 2: Partial initialization (remaining elements set to 0)
    int temperatures[5] = {72, 75, 80};

    // Method 3: Initialize all elements to zero
    int ages[5] = {0};

    // Printing the arrays
    printf("Scores array:\n");
    for (int i = 0; i < 5; i++) {
        printf("scores[%d] = %d\n", i, scores[i]);
    }

    printf("\nTemperatures array:\n");
    for (int i = 0; i < 5; i++) {
        printf("temperatures[%d] = %d\n", i, temperatures[i]);
    }

    printf("\nAges array:\n");
    for (int i = 0; i < 5; i++) {
        printf("ages[%d] = %d\n", i, ages[i]);
    }

    return 0;
}

Wenn Sie diesen Code ausführen, werden Sie sehen, wie verschiedene Initialisierungsmethoden in der Praxis funktionieren. Der Code zeigt drei Hauptmethoden zur Erstellung und Befüllung von Arrays, die jeweils einen anderen Zweck in der Programmierung erfüllen.

Kompilieren und führen Sie das Programm aus:

gcc array_initialization.c -o array_initialization
./array_initialization

Beispielausgabe:

Scores array:
scores[0] = 85
scores[1] = 92
scores[2] = 78
scores[3] = 90
scores[4] = 88

Temperatures array:
temperatures[0] = 72
temperatures[1] = 75
temperatures[2] = 80
temperatures[3] = 0
temperatures[4] = 0

Ages array:
ages[0] = 0
ages[1] = 0
ages[2] = 0
ages[3] = 0
ages[4] = 0

Lassen Sie uns die wichtigsten Konzepte der Array-Initialisierung, die jeder Anfänger verstehen sollte, anhand des Codes analysieren:

  • Methode 1: Vollständige Initialisierung int scores[5] = {85, 92, 78, 90, 88};: Hier deklarieren wir ein Array namens scores der Größe 5 und initialisieren es mit 5 bestimmten Werten. Dies ist eine einfache Möglichkeit, jeder Position im Array bei der Deklaration bestimmte Werte zuzuweisen. Jedes Element des Arrays wird gemäß der Reihenfolge der Werte in den geschweiften Klammern festgelegt.
  • Methode 2: Teilweise Initialisierung int temperatures[5] = {72, 75, 80};: In diesem Fall wird das temperatures-Array der Größe 5 nur mit drei Werten initialisiert. C behandelt dies, indem es die verbleibenden Elemente (an den Indizes 3 und 4) auf Null setzt. Die teilweise Initialisierung ist nützlich, wenn Sie die ersten wenigen Werte kennen und möchten, dass die restlichen auf Null gesetzt werden.
  • Methode 3: Initialisieren aller Elemente auf Null int ages[5] = {0};: Dies initialisiert ein Array namens ages der Größe 5, wobei alle Elemente auf Null gesetzt werden. Dies ist eine praktische Abkürzung, wenn Sie möchten, dass alle Werte im Array mit Null beginnen. Dies ist sehr üblich in Situationen wie der Zählung oder den Anfangszuständen von Datenstrukturen.
  • Die Array-Größe ist bei der Deklaration festgelegt: Es ist wichtig zu beachten, dass einmal, wenn Sie ein Array mit einer bestimmten Größe deklarieren (z. B. [5]), diese Größe später nicht geändert werden kann. Sie können keine weiteren Elemente hinzufügen oder entfernen, ohne ein neues Array zu erstellen.
  • Die Indizierung beginnt immer bei 0: Wie Sie bereits gesehen haben, werden Array-Elemente über Indizes zugegriffen, und diese Indizes beginnen immer mit 0 für das erste Element. Im scores-Array bezieht sich scores[0] auf das erste Element, scores[1] auf das zweite und so weiter.

Diese Initialisierungsmethoden bieten Flexibilität bei der Einrichtung und Arbeit mit Arrays. Wenn Sie in Ihrer C-Programmierreise voranschreiten, werden Sie diese Techniken als unschätzbar für die effiziente und saubere Verwaltung von Datensammlungen finden.

Zugriff auf Array-Elemente über Indizes

In C sind Arrays nullbasiert indiziert, was bedeutet, dass das erste Element am Index 0, das zweite am Index 1 und so weiter liegt. Dieses Konzept mag zunächst unintuitiv erscheinen, aber es ist eine Standardkonvention in vielen Programmiersprachen, die aus der niedrigschichtigen Speicherverwaltung stammt.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei:

  1. Klicken Sie mit der rechten Maustaste im Dateiexplorer und wählen Sie "Neue Datei".
  2. Benennen Sie die Datei array_indexing.c.
  3. Klicken Sie auf die Datei, um sie im Editor zu öffnen.

Schreiben wir ein Programm, das die Array-Indizierung und -Manipulation demonstriert:

#include <stdio.h>

int main() {
    // Declare and initialize an array of student grades
    int grades[5] = {85, 92, 78, 90, 88};

    // Accessing individual array elements
    printf("First grade (index 0): %d\n", grades[0]);
    printf("Third grade (index 2): %d\n", grades[2]);

    // Modifying array elements
    printf("\nBefore modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("grades[%d] = %d\n", i, grades[i]);
    }

    // Modify a specific element
    grades[1] = 95;  // Change the second grade
    grades[4] = 87;  // Change the last grade

    printf("\nAfter modification:\n");
    for (int i = 0; i < 5; i++) {
        printf("grades[%d] = %d\n", i, grades[i]);
    }

    // Calculate average grade
    int total = 0;
    for (int i = 0; i < 5; i++) {
        total += grades[i];
    }
    float average = (float)total / 5;
    printf("\nAverage grade: %.2f\n", average);

    return 0;
}

In diesem Beispiel arbeiten wir mit einem Array von Schülernoten. Der Code demonstriert mehrere wichtige Array-Operationen, die jeder Anfänger verstehen sollte. Wir beginnen damit, ein Array mit fünf Ganzzahl-Elementen zu deklarieren, die verschiedene Schülernoten repräsentieren.

Kompilieren und führen Sie das Programm aus:

gcc array_indexing.c -o array_indexing
./array_indexing

Beispielausgabe:

First grade (index 0): 85
Third grade (index 2): 78

Before modification:
grades[0] = 85
grades[1] = 92
grades[2] = 78
grades[3] = 90
grades[4] = 88

After modification:
grades[0] = 85
grades[1] = 95
grades[2] = 78
grades[3] = 90
grades[4] = 87

Average grade: 87.00

Die Ausgabe zeigt, wie wir auf bestimmte Array-Elemente zugreifen, ihre Werte ausgeben und sie ändern können. Die for-Schleifen demonstrieren eine effiziente Möglichkeit, alle Array-Elemente zu durchlaufen, was bei der Arbeit mit Arrays beliebiger Größe von entscheidender Bedeutung ist.

Wichtige Punkte zur Array-Indizierung, mit Betonung auf bestimmte Codezeilen:

  • Array-Indizes beginnen bei 0: Das erste Element im Array grades wird über grades[0] und nicht über grades[1] zugegriffen. Die printf-Anweisung printf("First grade (index 0): %d\n", grades[0]); demonstriert dieses Schlüsselkonzept.
  • Zugriff auf einzelne Elemente über array[index]: Die Anweisung printf("Third grade (index 2): %d\n", grades[2]); zeigt, wie man auf ein bestimmtes Element an einem gegebenen Index zugreift. Hier greifen wir auf das dritte Element am Index 2 zu.
  • Ändern von Array-Elementen durch Zuweisung neuer Werte: Die Zeilen grades[1] = 95; und grades[4] = 87; zeigen, wie man die im Array gespeicherten Werte ändern kann. Der Wert am Index 1 wird auf 95 und der Wert am Index 4 auf 87 aktualisiert. Es ist ein direkter Zugriff und eine Änderung über den Index und den Zuweisungsoperator.
  • Achten Sie darauf, nicht auf Indizes außerhalb der Array-Grenzen zuzugreifen: Wenn Sie versuchen, auf grades[5] zuzugreifen (denken Sie daran, dass das Array 5 Elemente mit den Indizes 0 bis 4 hat), verursachen Sie wahrscheinlich einen Fehler (dies wird als "Pufferüberlauf" oder "Zugriff außerhalb der Grenzen" bezeichnet). Der Zugriff auf einen nicht existierenden Index führt zu unvorhersehbarem Verhalten.
  • Verwenden Sie Schleifen, um effizient durch die Array-Elemente zu iterieren: Die for-Schleifen, wie diejenige, die zum Ausgeben des Arrays verwendet wird, sind eine effiziente Möglichkeit, jedes Element in einem Array sequentiell von Index 0 bis 4 zu durchlaufen:
for (int i = 0; i < 5; i++) {
    printf("grades[%d] = %d\n", i, grades[i]);
}

Diese Schleife verwendet die Variable i als Index von 0 bis 4.

Das Verständnis dieser Prinzipien wird Ihnen helfen, Arrays effektiv in Ihrer C-Programmierung zu manipulieren. Übung und Experimentieren sind der Schlüssel zur Beherrschung von Array-Operationen.

Ausgabe von Elementen in einer for-Schleife

Wenn Sie gerade erst mit der Programmierung beginnen, kann das Konzept von Schleifen abschreckend erscheinen. Doch sie sind unglaublich mächtige Werkzeuge, die es Ihnen ermöglichen, repetitive Aufgaben effizient und elegant auszuführen. Eine for-Schleife bietet eine strukturierte Möglichkeit, durch die Elemente eines Arrays zu iterieren und gibt Ihnen präzisen Kontroll über die Interaktion mit jedem Element.

Öffnen Sie die WebIDE und erstellen Sie eine neue Datei:

  1. Klicken Sie mit der rechten Maustaste im Dateiexplorer und wählen Sie "Neue Datei".
  2. Benennen Sie die Datei array_loop_print.c.
  3. Klicken Sie auf die Datei, um sie im Editor zu öffnen.

Schreiben wir ein Programm, das verschiedene Methoden zur Ausgabe von Array-Elementen demonstriert:

#include <stdio.h>

int main() {
    // Declare and initialize an array of temperatures
    int temperatures[5] = {72, 75, 80, 68, 85};

    // Method 1: Using a standard for loop with index
    printf("Method 1: Printing with index\n");
    for (int i = 0; i < 5; i++) {
        printf("Temperature %d: %d degrees\n", i + 1, temperatures[i]);
    }

    // Method 2: Printing array with descriptive labels
    printf("\nMethod 2: Printing with labels\n");
    char *days[] = {"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"};
    for (int i = 0; i < 5; i++) {
        printf("%s's temperature: %d degrees\n", days[i], temperatures[i]);
    }

    // Method 3: Calculating and printing additional information
    printf("\nMethod 3: Calculating average temperature\n");
    int total = 0;
    for (int i = 0; i < 5; i++) {
        total += temperatures[i];
        printf("Adding %d degrees\n", temperatures[i]);
    }
    float average = (float)total / 5;
    printf("Average temperature: %.1f degrees\n", average);

    return 0;
}

In diesem Beispiel geben wir nicht nur die Array-Elemente aus, sondern demonstrieren auch, wie vielseitig Schleifen sein können. Jede Methode zeigt einen anderen Ansatz bei der Arbeit mit Arrays und hilft Ihnen, die Flexibilität von for-Schleifen in der C-Programmierung zu verstehen.

Kompilieren und führen Sie das Programm aus:

gcc array_loop_print.c -o array_loop_print
./array_loop_print

Beispielausgabe:

Method 1: Printing with index
Temperature 1: 72 degrees
Temperature 2: 75 degrees
Temperature 3: 80 degrees
Temperature 4: 68 degrees
Temperature 5: 85 degrees

Method 2: Printing with labels
Monday's temperature: 72 degrees
Tuesday's temperature: 75 degrees
Wednesday's temperature: 80 degrees
Thursday's temperature: 68 degrees
Friday's temperature: 85 degrees

Method 3: Calculating average temperature
Adding 72 degrees
Adding 75 degrees
Adding 80 degrees
Adding 68 degrees
Adding 85 degrees
Average temperature: 76.0 degrees

Wichtige Punkte zu for-Schleifen und Arrays, mit Fokus auf den Code:

  • Die Schleifenvariable i beginnt bei 0 und geht bis array_length - 1: Die Standard-Initialisierung der Schleife for (int i = 0; i < 5; i++) in Methode 1 stellt sicher, dass die Schleife vom ersten Element (Index 0) bis zum letzten Element (Index 4) des Arrays temperatures iteriert und jedes Element ausgibt. Die Bedingung i < 5 bestimmt, wie lange die Schleife fortgesetzt wird.
  • Sie können den Schleifenindex verwenden, um auf Array-Elemente zuzugreifen: In der for-Schleife wird temperatures[i] verwendet, um auf das Element am entsprechenden Index i in jedem Schleifendurchlauf zuzugreifen. Dies zeigt, wie der Schleifenzähler als Array-Index fungiert.
  • Schleifen eignen sich hervorragend für die Ausführung von Operationen auf ganzen Arrays: Methode 3 zeigt ein Array mit einer for-Schleife, die eine Summe berechnet und zusätzliche Informationen während der Schleife ausgibt. Die for-Schleife wird verwendet, um alle Array-Elemente zu durchlaufen und die total-Summe zu berechnen.
  • Sie können Schleifen mit Berechnungen und zusätzlichen Arrays kombinieren: Methode 2 kombiniert die for-Schleife mit dem zusätzlichen days-Array, und Methode 3 führt eine Berechnung während der Schleife durch. Dies zeigt, wie man Arrays und Schleifen zusammen verwenden kann.

Das Verständnis dieser Konzepte wird Ihnen helfen, effizienteren und lesbareren Code zu schreiben. Wenn Sie in Ihrer Programmierreise voranschreiten, werden Sie feststellen, dass Schleifen und Arrays essentielle Werkzeuge bei der Lösung komplexer Probleme und der Implementierung ausgefeilter Algorithmen sind.

Fortgeschrittene Array-Operationen

In diesem Schritt werden wir einige fortgeschrittene Operationen erkunden, die Sie mit Arrays ausführen können, wie das Finden der maximalen und minimalen Werte sowie das Sortieren des Arrays. Diese Techniken sind für die Datenanalyse, -verarbeitung und die Implementierung von Algorithmen unerlässlich.

Schreiben wir ein Programm, um die maximalen und minimalen Werte in einem Array zu finden:

cd ~/project
touch find_max_min.c
#include <stdio.h>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    int max = numbers[0];
    int min = numbers[0];

    for (int i = 1; i < 5; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
        if (numbers[i] < min) {
            min = numbers[i];
        }
    }

    printf("Maximum value: %d\n", max);
    printf("Minimum value: %d\n", min);

    return 0;
}

Dieser Code demonstriert eine einfache, aber mächtige Technik zum Finden der maximalen und minimalen Werte in einem Array. Indem wir max und min mit dem ersten Element initialisieren und dann jedes nachfolgende Element vergleichen, können wir effizient die Extremwerte im Array identifizieren.

Wichtige Codezeilen:

  • Initialisierung: int max = numbers[0]; int min = numbers[0]; - Die Variablen max und min werden mit dem ersten Element des Arrays initialisiert. Dieser Schritt liefert den Ausgangspunkt für den Vergleich.
  • Vergleichsschleife: for (int i = 1; i < 5; i++) - Diese for-Schleife beginnt beim Index 1 (dem zweiten Element) und geht bis zum Ende des Arrays. Dadurch wird sichergestellt, dass jedes nachfolgende Element mit den bestehenden Maximal- und Minimalwerten verglichen wird.
  • Finden des Maximums: if (numbers[i] > max) { max = numbers[i]; } - Dieser Codeblock prüft, ob das aktuelle Element größer als der aktuelle max-Wert ist. Wenn dies der Fall ist, wird die Variable max auf den Wert des aktuellen Elements aktualisiert.
  • Finden des Minimums: if (numbers[i] < min) { min = numbers[i]; } - Ähnlich prüft dieser Codeblock, ob das aktuelle Element kleiner als der aktuelle min-Wert ist und aktualisiert min, wenn ein kleinerer Wert gefunden wird.

Als Nächstes schreiben wir ein Programm, um das Array in aufsteigender Reihenfolge mit dem Bubble-Sort-Algorithmus zu sortieren:

cd ~/project
touch bubble_sort.c
#include <stdio.h>

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

int main() {
    int numbers[5] = {50, 20, 30, 10, 40};

    bubbleSort(numbers, 5);

    printf("Sorted array:\n");
    for (int i = 0; i < 5; i++) {
        printf("numbers[%d] = %d\n", i, numbers[i]);
    }

    return 0;
}

Der Bubble-Sort-Algorithmus ist ein klassischer Sortieralgorithmus, der wiederholt durch die Liste geht, benachbarte Elemente vergleicht und sie vertauscht, wenn sie in der falschen Reihenfolge sind. Obwohl er nicht die effizienteste Sortiermethode für große Datensätze ist, bietet er eine hervorragende Einführung in Sortierkonzepte und die Manipulation von Arrays.

Wichtige Codezeilen:

  • Äußere Schleife: for (int i = 0; i < n-1; i++) - Diese äußere Schleife steuert die Anzahl der Durchläufe durch das Array. Die Schleife wird bis zu n - 1 Mal ausgeführt (wobei n die Größe des Arrays ist), da das größte Element nach jedem Durchlauf an seiner endgültigen Position sein wird.
  • Innere Schleife: for (int j = 0; j < n-i-1; j++) - Die innere Schleife führt die eigentlichen Vergleiche und Vertauschungen durch. Da die größten Elemente nach oben "aufsteigen", verringert sich der Bereich der inneren Schleife, daher haben wir n - i - 1 anstelle von n.
  • Vergleich: if (arr[j] > arr[j+1]) - Diese Anweisung prüft, ob das aktuelle Element größer als das nächste Element ist.
  • Vertauschung: Die Zeilen int temp = arr[j]; arr[j] = arr[j+1]; arr[j+1] = temp; führen die Vertauschung der beiden Elemente durch, wenn arr[j] größer als arr[j+1] ist. Eine temporäre Variable temp wird verwendet, um zu vermeiden, dass einer der Werte während der Vertauschung verloren geht.

Um die Programme zu kompilieren und auszuführen, verwenden Sie die folgenden Befehle im Terminal:

gcc find_max_min.c -o find_max_min
./find_max_min

gcc bubble_sort.c -o bubble_sort
./bubble_sort

Beispielausgabe für das Finden von Maximal- und Minimalwerten:

Maximum value: 50
Minimum value: 10

Beispielausgabe für das Sortieren:

Sorted array:
numbers[0] = 10
numbers[1] = 20
numbers[2] = 30
numbers[3] = 40
numbers[4] = 50

Diese Beispiele veranschaulichen grundlegende Array-Operationen, die die Bausteine für komplexere Datenverarbeitungstechniken in der C-Programmierung bilden.

Zusammenfassung

In diesem Lab haben wir die grundlegenden Konzepte der Array-Deklaration und -Initialisierung in der C-Programmierung gelernt. Wir haben die Syntax für die Deklaration eines Integer-Arrays untersucht, einschließlich der Initialisierung mit bestimmten Werten. Wir haben auch gelernt, wie man auf einzelne Elemente des Arrays über ihre Indizes zugreift und wie man die Array-Elemente in einer for-Schleife ausgibt. Schließlich haben wir einige fortgeschrittene Array-Operationen wie das Finden des maximalen und minimalen Werts sowie das Sortieren eines Arrays mit dem Bubble-Sort-Algorithmus erkundet. Diese Fähigkeiten sind für die Arbeit mit Arrays unerlässlich, die eine entscheidende Datenstruktur in der C-Programmierung sind.