Größtes und kleinstes Element in einem Array | C-Programmierung

Einführung

Das Finden der größten und kleinsten Elemente in einem Array ist ein häufiges Problem in der Programmierung, auf das Sie häufig stoßen werden. Diese Fähigkeit ist für verschiedene Anwendungen unerlässlich, wie beispielsweise bei der Datenanalyse, der Spieleentwicklung und Sortieralgorithmen.

In diesem Lab (Praktikum) werden Sie lernen, wie Sie ein C-Programm schreiben, das sowohl das größte als auch das kleinste Element in einem Ganzzahl-Array identifiziert. Wir werden den Prozess in klare, beherrschbare Schritte aufteilen, um Ihnen zu helfen, die Logik hinter dieser grundlegenden Programmiersprache zu verstehen.

Dieses Lab erfordert grundlegende Kenntnisse der C-Programmierung, einschließlich Variablen, Arrays, Schleifen und bedingten Anweisungen. Am Ende dieser Sitzung haben Sie ein vollständiges C-Programm erstellt, das zeigt, wie man Extreme in einem Datensatz findet.

Einrichten der Programmstruktur

Beginnen wir damit, eine neue C-Datei zu erstellen und die Grundstruktur unseres Programms einzurichten. Dies umfasst die erforderlichen Header-Dateien, die Hauptfunktion und die Variablendeklarationen.

Zunächst navigieren Sie in das Projektverzeichnis und erstellen eine neue Datei mit dem Namen main.c:

cd ~/project
touch main.c

Öffnen Sie nun die Datei main.c im Editor und fügen Sie folgenden Code hinzu:

#include <stdio.h>

int main() {
    // Wir werden ein Array mit einer maximalen Kapazität von 50 Elementen deklarieren
    int array[50];
    // Variablen zur Speicherung der Größe des Arrays und des Schleifenzählers
    int size, i;
    // Variablen zur Speicherung des größten und kleinsten Elements
    int largest, smallest;

    printf("Finding Largest and Smallest Elements in an Array\n");
    printf("------------------------------------------------\n\n");

    return 0;
}

Dieser Code richtet die Grundstruktur unseres Programms ein. Lassen Sie uns verstehen, was jeder Teil tut:

#include <stdio.h> inkludiert die Standard-Eingabe/Ausgabe-Bibliothek, die Funktionen wie printf() und scanf() bereitstellt.
Die main()-Funktion ist der Einstiegspunkt unseres Programms.
Wir deklarieren ein Ganzzahl-Array namens array mit einer Kapazität von 50 Elementen.
Die Variable size speichert die Anzahl der Elemente, die der Benutzer eingeben möchte.
Die Variable i wird als Schleifenzähler verwendet.
Die Variablen largest und smallest speichern den maximalen und minimalen Wert, der im Array gefunden wird.

Speichern Sie die Datei nach dem Hinzufügen dieses Codes. Dies legt die Grundlage für unser Programm.

Erhalten von Benutzereingaben

Jetzt, da unsere Programmstruktur fertig ist, fügen wir Code hinzu, um Eingaben vom Benutzer zu erhalten. Wir müssen den Benutzer nach der Größe des Arrays fragen und dann die Array-Elemente sammeln.

Öffnen Sie die Datei main.c im Editor und ändern Sie sie, indem Sie folgenden Code vor der Anweisung return 0; hinzufügen:

// Benutzer nach der Größe des Arrays fragen
printf("Enter the size of the array (max 50): ");
scanf("%d", &size);

// Die eingegebene Größe validieren
if (size <= 0 || size > 50) {
    printf("Invalid array size. Please enter a size between 1 and 50.\n");
    return 1;
}

// Array-Elemente vom Benutzer erhalten
printf("\nEnter %d elements of the array:\n", size);
for (i = 0; i < size; i++) {
    printf("Element %d: ", i + 1);
    scanf("%d", &array[i]);
}

// Das eingegebene Array anzeigen
printf("\nThe array you entered is: [ ");
for (i = 0; i < size; i++) {
    printf("%d ", array[i]);
}
printf("]\n\n");

Dieser Code:

Fordert den Benutzer auf, die Größe des Arrays einzugeben.
Validiert, dass die Größe zwischen 1 und 50 liegt.
Bittet den Benutzer, jedes Element des Arrays nacheinander einzugeben.
Zeigt das eingegebene Array dem Benutzer zur Bestätigung an.

Lassen Sie uns unser Programm kompilieren und ausführen, um zu sehen, was wir bisher haben:

gcc main.c -o main
./main

Sie sollten eine Aufforderung sehen, die Sie nach der Array-Größe fragt. Geben Sie eine kleine Zahl wie 5 ein und dann 5 Werte. Das Programm wird das eingegebene Array anzeigen.

Beispielsweise sollten Sie, wenn Sie 5 für die Größe eingeben und dann die Werte 10, 25, 5, 17 und 9 eingeben, die folgende Ausgabe sehen:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Jetzt, da wir die Array-Elemente vom Benutzer gesammelt haben, können wir fortfahren und die größten und kleinsten Werte finden.

Finden des größten Elements

Jetzt fügen wir Code hinzu, um das größte Element im Array zu finden. Die Strategie lautet:

Nehmen Sie an, dass das erste Element das größte ist.
Vergleichen Sie jedes nachfolgende Element mit dem aktuellen größten Element.
Wenn ein größeres Element gefunden wird, aktualisieren Sie den größten Wert.

Fügen Sie folgenden Code in Ihre main.c-Datei vor der Anweisung return 0; ein:

// Initialisieren Sie 'largest' mit dem ersten Element des Arrays
largest = array[0];

// Das größte Element finden
printf("Finding the largest element...\n");
for (i = 1; i < size; i++) {
    if (array[i] > largest) {
        largest = array[i];
        printf("New largest found at position %d: %d\n", i + 1, largest);
    }
}

printf("\nThe largest element in the array is: %d\n\n", largest);

Dieser Code initialisiert die Variable largest mit dem ersten Element des Arrays. Anschließend wird das Array beginnend mit dem zweiten Element (Index 1) durchlaufen, wobei jedes Element mit dem aktuellen größten Wert verglichen wird. Wenn ein größeres Element gefunden wird, wird die Variable largest aktualisiert und eine Meldung ausgegeben.

Lassen Sie uns unser Programm kompilieren und ausführen, um die Ergebnisse zu sehen:

gcc main.c -o main
./main

Geben Sie wie zuvor die Array-Größe und die Elemente ein. Wenn Sie beispielsweise die Werte 10, 25, 5, 17 und 9 eingeben, sollten Sie eine Ausgabe ähnlich der folgenden sehen:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Finding the largest element...
New largest found at position 2: 25

The largest element in the array is: 25

Dies zeigt, wie unser Programm das größte Element im Array findet. Der Algorithmus beginnt mit dem ersten Element als dem größten und aktualisiert diesen Wert, wenn er einen größeren Wert findet.

Finden des kleinsten Elements

Nachdem wir das größte Element gefunden haben, fügen wir nun Code hinzu, um das kleinste Element im Array zu finden. Die Strategie ist ähnlich:

Nehmen Sie an, dass das erste Element das kleinste ist.
Vergleichen Sie jedes nachfolgende Element mit dem aktuellen kleinsten Element.
Wenn ein kleineres Element gefunden wird, aktualisieren Sie den kleinsten Wert.

Fügen Sie folgenden Code in Ihre main.c-Datei vor der Anweisung return 0; ein:

// Initialisieren Sie 'smallest' mit dem ersten Element des Arrays
smallest = array[0];

// Das kleinste Element finden
printf("Finding the smallest element...\n");
for (i = 1; i < size; i++) {
    if (array[i] < smallest) {
        smallest = array[i];
        printf("New smallest found at position %d: %d\n", i + 1, smallest);
    }
}

printf("\nThe smallest element in the array is: %d\n", smallest);

Dieser Code initialisiert die Variable smallest mit dem ersten Element des Arrays. Anschließend wird das Array beginnend mit dem zweiten Element (Index 1) durchlaufen, wobei jedes Element mit dem aktuellen kleinsten Wert verglichen wird. Wenn ein kleineres Element gefunden wird, wird die Variable smallest aktualisiert und eine Meldung ausgegeben.

Lassen Sie uns unser Programm kompilieren und ausführen, um die vollständigen Ergebnisse zu sehen:

gcc main.c -o main
./main

Geben Sie wie zuvor die Array-Größe und die Elemente ein. Wenn Sie beispielsweise die Werte 10, 25, 5, 17 und 9 eingeben, sollten Sie eine Ausgabe ähnlich der folgenden sehen:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Finding the largest element...
New largest found at position 2: 25

The largest element in the array is: 25

Finding the smallest element...
New smallest found at position 3: 5

The smallest element in the array is: 5

Dies zeigt, wie unser Programm sowohl das größte als auch das kleinste Element im Array findet. Die Algorithmen beginnen mit dem ersten Element und aktualisieren jeweils, wenn sie einen größeren oder kleineren Wert finden.

Optimieren des Programms und vollständiger Code

Jetzt, da wir ein funktionierendes Programm haben, lassen Sie uns es optimieren, indem wir die Suche nach dem größten und dem kleinsten Element in einer einzigen Schleife kombinieren. Dies ist effizienter, da wir das Array nur einmal anstatt zweimal durchlaufen müssen.

Öffnen Sie die Datei main.c und ersetzen Sie den gesamten Inhalt durch die folgende optimierte Version:

#include <stdio.h>

int main() {
    // We'll declare an array with a maximum capacity of 50 elements
    int array[50];
    // Variables to store the size of the array and loop counter
    int size, i;
    // Variables to store the largest and smallest elements
    int largest, smallest;

    printf("Finding Largest and Smallest Elements in an Array\n");
    printf("------------------------------------------------\n\n");

    // Ask user for the size of the array
    printf("Enter the size of the array (max 50): ");
    scanf("%d", &size);

    // Validate the input size
    if (size <= 0 || size > 50) {
        printf("Invalid array size. Please enter a size between 1 and 50.\n");
        return 1;
    }

    // Get array elements from the user
    printf("\nEnter %d elements of the array:\n", size);
    for (i = 0; i < size; i++) {
        printf("Element %d: ", i + 1);
        scanf("%d", &array[i]);
    }

    // Display the entered array
    printf("\nThe array you entered is: [ ");
    for (i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("]\n\n");

    // Initialize largest and smallest with the first element
    largest = smallest = array[0];

    // Find both the largest and smallest elements in a single pass
    printf("Searching for largest and smallest elements...\n");
    for (i = 1; i < size; i++) {
        // Check for largest
        if (array[i] > largest) {
            largest = array[i];
            printf("New largest found at position %d: %d\n", i + 1, largest);
        }

        // Check for smallest
        if (array[i] < smallest) {
            smallest = array[i];
            printf("New smallest found at position %d: %d\n", i + 1, smallest);
        }
    }

    // Display results
    printf("\nResults:\n");
    printf("- The largest element in the array is: %d\n", largest);
    printf("- The smallest element in the array is: %d\n", smallest);

    // Calculate and display the range
    printf("- The range (difference between largest and smallest) is: %d\n", largest - smallest);

    return 0;
}

Diese optimierte Version:

Nutzt eine einzige Schleife, um sowohl das größte als auch das kleinste Element zu finden, was das Programm effizienter macht.
Initialisiert sowohl largest als auch smallest mit dem ersten Element des Arrays.
Fügt eine Berechnung für den Wertebereich (die Differenz zwischen dem größten und dem kleinsten Wert) hinzu.

Lassen Sie uns unser optimiertes Programm kompilieren und ausführen:

gcc main.c -o main
./main

Geben Sie wie zuvor die Array-Größe und die Elemente ein. Wenn Sie beispielsweise die Werte 10, 25, 5, 17 und 9 eingeben, sollten Sie eine Ausgabe ähnlich der folgenden sehen:

Finding Largest and Smallest Elements in an Array
------------------------------------------------

Enter the size of the array (max 50): 5

Enter 5 elements of the array:
Element 1: 10
Element 2: 25
Element 3: 5
Element 4: 17
Element 5: 9

The array you entered is: [ 10 25 5 17 9 ]

Searching for largest and smallest elements...
New largest found at position 2: 25
New smallest found at position 3: 5

Results:
- The largest element in the array is: 25
- The smallest element in the array is: 5
- The range (difference between largest and smallest) is: 20

Diese optimierte Version liefert die gleichen Ergebnisse wie zuvor, ist aber effizienter und enthält zusätzliche Informationen über den Wertebereich.

Bei der Arbeit mit großen Arrays können diese Effizienzverbesserungen die Rechenzeit erheblich reduzieren, was bei der Programmierung eine wichtige Überlegung ist.

Zusammenfassung

In diesem Lab haben Sie erfolgreich ein C-Programm erstellt, das sowohl das größte als auch das kleinste Element in einem Array findet. Lassen Sie uns zusammenfassen, was Sie gelernt haben:

Sie haben eine grundlegende Programmstruktur mit den erforderlichen Variablendeklarationen eingerichtet.
Sie haben Code geschrieben, um Benutzereingaben für die Array-Größe und die Elemente zu erhalten.
Sie haben einen Algorithmus implementiert, um das größte Element im Array zu finden.
Sie haben einen ähnlichen Algorithmus implementiert, um das kleinste Element im Array zu finden.
Sie haben das Programm optimiert, indem Sie beide Suchvorgänge in einer einzigen Schleife kombiniert und zusätzliche Funktionalität hinzugefügt haben.

Dieses Lab hat mehrere grundlegende Programmierkonzepte behandelt:

Arrays und Array-Durchlauf
Verwendung von Schleifen zur Iteration
Bedingte Anweisungen
Algorithmus-Optimierung
Erhalten und Validieren von Benutzereingaben

Diese Fähigkeiten sind für jeden Programmierer unerlässlich und bilden die Grundlage für komplexere Datenstrukturen und Algorithmen. Die Fähigkeit, Extreme in einem Datensatz zu finden, ist in vielen Programmier-Szenarien eine häufige Anforderung, wie beispielsweise beim Finden von Highscores in Spielen, der Analyse von Temperaturwerten oder der Verarbeitung von Finanzdaten.

Sie können dieses Programm weiter erweitern, indem Sie Funktionen hinzufügen wie:

Berechnen des Durchschnitts aller Array-Elemente
Sortieren des Arrays
Finden des Medianwerts
Zählen der Vorkommen bestimmter Werte

Üben Sie diese Konzepte weiterhin, um Ihre Programmierfähigkeiten zu stärken.

Suchen der größten und kleinsten Array-Elemente in C

Einführung

Einrichten der Programmstruktur

Erhalten von Benutzereingaben

Finden des größten Elements

Finden des kleinsten Elements

Optimieren des Programms und vollständiger Code

Zusammenfassung