0Pricing
C Academy · Lektion

qsort mit Vergleichsfunktionen

Callbacks der Standardbibliothek

qsort mit Vergleichsfunktionen ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Das standardmäßige qsort

Die Standardbibliothek stellt qsort in <stdlib.h> bereit. Dabei handelt es sich um eine generische Sortierfunktion, die mithilfe eines Vergleichs-Callbacks für Arrays beliebiger Typen funktioniert.

#include <stdio.h>
#include <stdlib.h>

int cmp_int(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(void) {
    int a[] = {3, 1, 2};
    qsort(a, 3, sizeof(int), cmp_int);
    printf("%d %d %d\n", a[0], a[1], a[2]);
    return 0;
}

Die qsort-Signatur

qsort(base, count, size, compare) erwartet den Anfang des Arrays, die Elementanzahl, die Elementgröße und einen Vergleichs-Callback.

Die Funktion ist generisch, weil sie mit rohen Bytes und Ihrem Vergleichs-Callback arbeitet.

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    return *(const int*)a - *(const int*)b;
}

int main(void) {
    int a[] = {9, 4, 7, 1};
    qsort(a, 4, sizeof(int), cmp);
    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");
    return 0;
}

Die Vereinbarung für den Vergleich

Der Vergleichs-Callback gibt einen negativen Wert zurück, wenn das erste Element vor dem zweiten stehen soll, 0 bei Gleichheit und einen positiven Wert, wenn es danach stehen soll.

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    int x = *(const int*)a, y = *(const int*)b;
    if (x < y) return -1;
    if (x > y) return 1;
    return 0;
}

int main(void) {
    int a[] = {5, 2, 8, 2};
    qsort(a, 4, sizeof(int), cmp);
    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");
    return 0;
}

void-Zeiger umwandeln

Der Vergleichs-Callback erhält für jedes Element einen const void *. Wandeln Sie diese Zeiger in den korrekten Typ um und dereferenzieren Sie sie, um die Werte zu lesen.

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    double x = *(const double*)a;
    double y = *(const double*)b;
    return (x > y) - (x < y);
}

int main(void) {
    double d[] = {2.5, 1.1, 3.3};
    qsort(d, 3, sizeof(double), cmp);
    printf("%.1f %.1f %.1f\n", d[0], d[1], d[2]);
    return 0;
}

Absteigende Reihenfolge

Kehren Sie den Vergleich um, um vom größten zum kleinsten Wert zu sortieren.

#include <stdio.h>
#include <stdlib.h>

int desc(const void *a, const void *b) {
    int x = *(const int*)a, y = *(const int*)b;
    return (y > x) - (y < x);
}

int main(void) {
    int a[] = {1, 5, 3, 2};
    qsort(a, 4, sizeof(int), desc);
    for (int i = 0; i < 4; i++) printf("%d ", a[i]);
    printf("\n");
    return 0;
}

Überlauf bei Subtraktion vermeiden

Der Rückgabewert x - y kann bei großen Ganzzahlen einen Überlauf verursachen. Das sichere Idiom (x > y) - (x < y) vermeidet dies.

#include <stdio.h>
#include <stdlib.h>

int safe_cmp(const void *a, const void *b) {
    int x = *(const int*)a, y = *(const int*)b;
    return (x > y) - (x < y);
}

int main(void) {
    int a[] = {100, -100, 0};
    qsort(a, 3, sizeof(int), safe_cmp);
    for (int i = 0; i < 3; i++) printf("%d ", a[i]);
    printf("\n");
    return 0;
}

Strings sortieren

Bei einem Array aus char * ist jedes Element selbst ein Zeiger. Wandeln Sie daher in const char * const * um und vergleichen Sie mit strcmp.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int cmp_str(const void *a, const void *b) {
    const char *sa = *(const char * const *)a;
    const char *sb = *(const char * const *)b;
    return strcmp(sa, sb);
}

int main(void) {
    const char *w[] = {"pear", "apple", "fig"};
    qsort(w, 3, sizeof(char*), cmp_str);
    for (int i = 0; i < 3; i++) printf("%s ", w[i]);
    printf("\n");
    return 0;
}

Strukturen sortieren

qsort verarbeitet auch Arrays aus Strukturen. Vergleichen Sie innerhalb des Vergleichs-Callbacks ein ausgewähltes Feld.

#include <stdio.h>
#include <stdlib.h>

typedef struct { char name; int age; } Person;

int by_age(const void *a, const void *b) {
    int x = ((const Person*)a)->age;
    int y = ((const Person*)b)->age;
    return (x > y) - (x < y);
}

int main(void) {
    Person p[] = {{'C',30},{'A',20},{'B',25}};
    qsort(p, 3, sizeof(Person), by_age);
    for (int i = 0; i < 3; i++) printf("%c:%d ", p[i].name, p[i].age);
    printf("\n");
    return 0;
}

bsearch verwendet dasselbe Prinzip

bsearch führt mithilfe eines Vergleichs-Callbacks mit derselben Vereinbarung wie bei qsort eine binäre Suche in einem sortierten Array durch.

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    return (*(const int*)a) - (*(const int*)b);
}

int main(void) {
    int a[] = {1, 3, 5, 7, 9};
    int key = 7;
    int *found = bsearch(&key, a, 5, sizeof(int), cmp);
    printf("found: %d\n", found ? *found : -1);
    return 0;
}

Mehrere Sortierschlüssel

Ein Vergleichs-Callback kann zunächst ein primäres Feld und bei Gleichheit anschließend ein sekundäres Feld vergleichen.

#include <stdio.h>
#include <stdlib.h>

typedef struct { int grade; int id; } Rec;

int cmp(const void *a, const void *b) {
    const Rec *x = a, *y = b;
    if (x->grade != y->grade) return x->grade - y->grade;
    return x->id - y->id;
}

int main(void) {
    Rec r[] = {{90,2},{90,1},{80,3}};
    qsort(r, 3, sizeof(Rec), cmp);
    for (int i = 0; i < 3; i++) printf("%d/%d ", r[i].grade, r[i].id);
    printf("\n");
    return 0;
}

Warum generisches Sortieren wichtig ist

Da qsort den Algorithmus vom Vergleich trennt, kann eine gut getestete Funktion jeden Datentyp sortieren, den Sie vergleichen können.

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    char x = *(const char*)a, y = *(const char*)b;
    return (x > y) - (x < y);
}

int main(void) {
    char s[] = "dcba";
    qsort(s, 4, sizeof(char), cmp);
    printf("%s\n", s);
    return 0;
}

Kurzer Test

Testen Sie Ihr Verständnis von qsort-Vergleichs-Callbacks.

Zusammenfassung

Sie haben gelernt, qsort mit Vergleichs-Callbacks zu verwenden:

  • qsort(base, count, size, compare) sortiert Arrays beliebiger Typen generisch.
  • Der Vergleichs-Callback erhält zwei const void * und gibt einen negativen, den Wert 0 oder einen positiven Wert zurück.
  • Verwenden Sie (x > y) - (x < y), um Überläufe zu vermeiden.
  • Dieselbe Vergleichsvereinbarung wird von bsearch, beim Sortieren von Strukturen und bei Sortierungen mit mehreren Schlüsseln verwendet.

Häufig gestellte Fragen

Ist die Lektion „qsort mit Vergleichsfunktionen“ kostenlos?

Ja — der vollständige Text von „qsort mit Vergleichsfunktionen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „qsort mit Vergleichsfunktionen“?

Callbacks der Standardbibliothek Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „qsort mit Vergleichsfunktionen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Funktionszeiger deklarieren
  2. Funktionen übergeben
  3. qsort mit Vergleichsfunktionen
  4. Tabellen mit Funktionszeigern
← Zurück zu C Academy