c语言如何直接调用排序函数

C语言直接调用排序函数的方式包括：使用标准库函数qsort、编写自定义排序函数、使用第三方库函数。其中，标准库函数qsort是最常用的方式。接下来，我们将详细介绍如何使用qsort函数进行排序，并且探讨编写自定义排序函数以及使用第三方库的方式。

一、使用标准库函数qsort

1. 什么是qsort函数

qsort是C标准库提供的通用排序函数，定义在stdlib.h头文件中。它使用快速排序算法对任意类型的数组进行排序。其原型如下：

void qsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));

base：指向要排序的数组的指针。
num：数组中元素的个数。
size：每个元素的大小（以字节为单位）。
compar：用于比较两个元素的函数的指针。

2. qsort函数的使用步骤

a. 定义比较函数

比较函数是qsort的核心，它决定了排序的规则。比较函数接受两个const void*类型的参数，并返回一个整数值：

如果第一个参数小于第二个参数，则返回负值。
如果第一个参数等于第二个参数，则返回零。
如果第一个参数大于第二个参数，则返回正值。

例如，对于整数数组，可以这样定义比较函数：

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

b. 调用qsort函数

定义好比较函数后，就可以调用qsort函数进行排序：

#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}
int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    qsort(arr, n, sizeof(int), compare);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

在这个例子中，qsort函数使用快速排序算法对数组arr进行排序，并将结果打印出来。

二、编写自定义排序函数

虽然qsort函数非常强大，但有时我们需要更精细的控制或者优化。在这种情况下，可以编写自己的排序函数。这里我们介绍两种常见的排序算法：冒泡排序和归并排序。

1. 冒泡排序

冒泡排序是最简单的排序算法之一。它反复扫描待排序的数组，每次比较相邻的两个元素，如果它们的顺序错误就交换它们。这个过程重复进行，直到数组有序。

#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 arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubbleSort(arr, n);
    printf("Sorted array: n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

在这个例子中，bubbleSort函数使用冒泡排序算法对数组arr进行排序，并将结果打印出来。

2. 归并排序

归并排序是一种有效的、稳定的排序算法，适用于大数据集。它采用分治策略，将数组分成两个子数组，分别排序后再合并。

#include <stdio.h>
#include <stdlib.h>
void merge(int arr[], int l, int m, int r) {
    int i, j, k;
    int n1 = m - l + 1;
    int n2 = r - m;
    int L[n1], R[n2];
    for (i = 0; i < n1; i++) {
        L[i] = arr[l + i];
    }
    for (j = 0; j < n2; j++) {
        R[j] = arr[m + 1+ j];
    }
    i = 0;
    j = 0;
    k = l;
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }
}
void mergeSort(int arr[], int l, int r) {
    if (l < r) {
        int m = l+(r-l)/2;
        mergeSort(arr, l, m);
        mergeSort(arr, m+1, r);
        merge(arr, l, m, r);
    }
}
int main() {
    int arr[] = {12, 11, 13, 5, 6, 7};
    int arr_size = sizeof(arr)/sizeof(arr[0]);
    printf("Given array is n");
    for (int i = 0; i < arr_size; i++) {
        printf("%d ", arr[i]);
    }
    mergeSort(arr, 0, arr_size - 1);
    printf("nSorted array is n");
    for (int i = 0; i < arr_size; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

在这个例子中，mergeSort函数使用归并排序算法对数组arr进行排序，并将结果打印出来。

三、使用第三方库函数

除了标准库和自定义排序函数外，还可以使用一些第三方库来进行排序。例如，GNU C库（glibc）提供了一些扩展的排序函数，如heapsort和mergesort。

1. 使用heapsort函数

heapsort函数是glibc提供的一种堆排序算法，定义在stdlib.h头文件中。其原型如下：

int heapsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));

使用方法与qsort类似：

#include <stdio.h>
#include <stdlib.h>
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}
int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int n = sizeof(arr)/sizeof(arr[0]);
    heapsort(arr, n, sizeof(int), compare);
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

在这个例子中，heapsort函数使用堆排序算法对数组arr进行排序，并将结果打印出来。

2. 使用mergesort函数

mergesort函数是glibc提供的另一种归并排序算法，定义在stdlib.h头文件中。其原型如下：

int mergesort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));