C语言排序算法

冒泡排序

1.什么是冒泡排序？

冒泡排序是一种简单的排序算法，它通过多次比较和交换相邻元素的方式，将待排序的元素逐步移动到正确的位置上，从而实现排序的目的。

冒泡排序的基本思想如下：

1. 从待排序的元素序列的起始位置开始，比较相邻的两个元素，如果它们的顺序错误（比如前面的元素大于后面的元素），则交换它们的位置。
2. 继续比较下一对相邻元素，重复上述比较和交换的过程，直到整个序列中的所有元素都被比较过一次。
3. 重复上述步骤，每次比较的元素数量减少一个（因为每次比较都会将当前未排序部分的最大元素移动到已排序部分的末尾），直到所有元素都排好序。

这个过程就像是每一轮都把最大的元素像气泡一样逐渐往后“冒泡”，因此得名冒泡排序。

冒泡排序是一种稳定的排序算法，它的时间复杂度为 O(n^2)，其中 n 是待排序序列的长度。虽然冒泡排序在大规模数据集上的性能不如其他高级排序算法，但对于小型数据集或已经基本有序的数据集，冒泡排序是一种简单有效的选择。

希望对你有帮助！如果还有其他问题，请随时提问。

2.案例

下面是一个使用冒泡排序算法对整数数组进行排序的示例：

#include <stdio.h>

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

void printArray(int arr[], int size) {
    int i;
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("Original array: ");
    printArray(arr, size);

    bubbleSort(arr, size);

    printf("Sorted array: ");
    printArray(arr, size);

    return 0;
}

在上述示例中，bubbleSort 函数使用冒泡排序算法对传入的整数数组进行排序。它使用了两个嵌套的循环，外部循环控制迭代次数，内部循环用于比较相邻元素并进行交换。通过多次迭代，较大的元素逐渐移动到数组的末尾，实现排序。

printArray 函数用于打印数组的元素。

在 main 函数中，我们声明一个整数数组 arr，并计算数组的大小。然后，我们打印原始数组，调用 bubbleSort 函数对数组进行排序，并打印排序后的数组。

运行上述代码，输出将为：

Original array: 64 34 25 12 22 11 90
Sorted array: 11 12 22 25 34 64 90

可以看到，冒泡排序算法成功对数组进行了排序。注意，冒泡排序算法的时间复杂度为 O(n^2)，在处理大型数据集时可能不是最优的选择，但它是一个简单直观的排序算法。

快速排序

1.什么是快速排序

快速排序是一种常用的排序算法，它采用了分治的思想来实现排序。它的基本思想是选择一个基准元素，将待排序的序列分割成两部分，其中一部分的所有元素都小于基准元素，另一部分的所有元素都大于基准元素，然后对这两部分分别进行递归排序，最终得到有序序列。

下面是快速排序的基本步骤：

1. 选择一个基准元素（通常是序列的第一个或最后一个元素）。
2. 将序列分割成两部分，使得左边部分的所有元素都小于基准元素，右边部分的所有元素都大于基准元素。这个过程称为分区（Partitioning）。
3. 对左右两个分区分别递归地应用快速排序算法，直到每个分区只包含一个元素或为空。
4. 合并左右两个分区，得到最终的有序序列。

快速排序的关键在于分区过程，常用的分区算法是 Hoare 分区和 Lomuto 分区。其中，Hoare 分区算法使用两个指针从序列的两端向中间扫描，交换不符合顺序的元素，最终确定基准元素的位置。Lomuto 分区算法则使用一个指针从序列的一端向另一端扫描，并将小于基准元素的元素放在序列的左边，最后将基准元素插入到正确的位置上。

快速排序的平均时间复杂度为 O(nlogn)，其中 n 是待排序序列的长度。它是一种原地排序算法，不需要额外的存储空间，但在最坏情况下（如序列已经有序或逆序），时间复杂度可达到 O(n^2)。

快速排序是一种高效的排序算法，被广泛应用于各种编程语言和排序库中。

希望对你有帮助！如果还有其他问题，请随时提问。

2.案例

下面是一个使用快速排序算法对整数数组进行排序的示例：

#include <stdio.h>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int partition(int arr[], int low, int high) {
    int pivot = arr[high];
    int i = (low - 1);

    for (int j = low; j <= high - 1; j++) {
        if (arr[j] < pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]);
    return (i + 1);
}

void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quickSort(arr, low, pi - 1);
        quickSort(arr, pi + 1, high);
    }
}

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("Original array: ");
    printArray(arr, size);

    quickSort(arr, 0, size - 1);

    printf("Sorted array: ");
    printArray(arr, size);

    return 0;
}

在上述示例中，swap 函数用于交换两个元素的值。

partition 函数用于选择一个基准元素（通常是数组的最后一个元素），并将数组分为两个部分，左侧的元素小于基准元素，右侧的元素大于基准元素。它通过遍历数组，将小于基准元素的元素放到左侧，大于基准元素的元素放到右侧，并返回基准元素的索引。

quickSort 函数是递归地对数组进行快速排序。它选择一个基准元素，将数组分为两个部分，并对这两个部分分别调用 quickSort 函数进行排序。

在 main 函数中，我们声明一个整数数组 arr，并计算数组的大小。然后，我们打印原始数组，调用 quickSort 函数对数组进行排序，并打印排序后的数组。

运行上述代码，输出将为：

Original array: 64 34 25 12 22 11 90
Sorted array: 11 12 22 25 34 64 90

可以看到，快速排序算法成功对数组进行了排序。快速排序算法的平均时间复杂度为 O(n log n)，在处理大型数据集时具有较高的效率。

qsort函数用法

1.什么是qsort函数

qsort 是 C 语言标准库中提供的一个函数，用于对数组进行快速排序。它是 “quick sort” 的缩写。

快速排序是一种常用的排序算法，具有较高的效率。它的基本思想是通过选择一个基准元素，将数组分为两个部分，一部分是小于基准元素的元素，另一部分是大于基准元素的元素。然后，对这两个部分分别递归地应用快速排序，直到整个数组有序。

qsort 函数提供了一个方便的方式来对数组进行快速排序，而无需手动实现快速排序算法。它接受四个参数：

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

qsort 函数通过调用指定的比较函数 compar 来确定元素之间的顺序。比较函数接受两个指向待比较元素的指针，并返回一个整数值，表示两个元素的相对顺序。

使用 qsort 函数时，需要提供一个自定义的比较函数，以便根据需要对数组元素进行排序。

总之，qsort 函数是 C 语言标准库中提供的一个快速排序函数，通过提供自定义的比较函数，可以对不同类型的数组进行排序，简化了快速排序算法的实现过程。
qsort 是 C 语言标准库中提供的一个函数，用于对数组进行快速排序。它的函数原型如下：

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

下面是 qsort 函数的参数说明：

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

compar 函数是 qsort 函数的一个重要参数，用于指定元素的比较方式。它是一个用户定义的函数，接受两个指向待比较元素的指针，并返回一个整数值，表示两个元素的相对顺序。compar 函数的返回值可以有三种情况：

• 如果返回值小于 0，则表示第一个元素应该排在第二个元素之前。
• 如果返回值等于 0，则表示两个元素相等，顺序不变。
• 如果返回值大于 0，则表示第一个元素应该排在第二个元素之后。

2.案例

下面是一个示例，演示如何使用 qsort 函数对整数数组进行排序：

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

// 比较函数
int compare(const void* a, const void* b) {
    int num1 = *(int*)a;
    int num2 = *(int*)b;
    return num1 - num2;
}

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int size = sizeof(arr) / sizeof(arr[0]);

    printf("Original array: ");
    printArray(arr, size);

    qsort(arr, size, sizeof(int), compare);

    printf("Sorted array: ");
    printArray(arr, size);

    return 0;
}

在上述示例中，我们定义了一个比较函数 compare，用于比较两个整数。然后，我们声明一个整数数组 arr，并计算数组的大小。我们打印原始数组，调用 qsort 函数对数组进行排序，并打印排序后的数组。

运行上述代码，输出将为：

Original array: 64 34 25 12 22 11 90
Sorted array: 11 12 22 25 34 64 90

可以看到，qsort 函数成功对数组进行了排序。通过提供自定义的比较函数，我们可以根据需要对不同类型的数组进行排序。