C语言qsort，C++sort详解及对比

C语言qsort

qsort 是 C 标准库中的一个函数，用于对数组进行快速排序。其定义在 <stdlib.h> 头文件中。qsort 函数提供了一种通用的排序方法，可以排序各种数据类型的数组，只需提供一个比较函数来定义排序顺序。以下是 qsort 的详细介绍：

函数原型

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

参数说明

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

比较函数

compar 是一个函数指针，比较函数的原型如下：

int compar(const void *a, const void *b);

• a 和 b 分别指向要比较的两个元素。
• 如果 a 小于 b，返回负值。
• 如果 a 等于 b，返回 0。
• 如果 a 大于 b，返回正值。

示例代码

以下是一个使用 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 进行排序
    qsort(arr, n, sizeof(int), compare);

    // 输出排序后的数组
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}

工作原理

qsort 函数实现了快速排序算法，通过递归的方式将数组分成较小的部分，然后分别排序。通过调用用户提供的比较函数来确定元素的顺序。

使用注意事项

1. 确保比较函数能够正确处理数组元素的比较，并返回合适的值。
2. qsort 可以用于各种数据类型，只需提供适当的比较函数。例如，可以用来排序字符串数组、结构体数组等。

通过 qsort 函数，C 语言能够以简洁而高效的方式实现数组排序，适用于各种复杂的数据类型和排序需求。

C++sort

std::sort 是 C++ 标准库中的一个函数，用于对容器中的元素进行排序。它定义在 <algorithm> 头文件中，是一种基于快速排序算法的通用排序函数。以下是 std::sort 的详细介绍：

函数原型

std::sort 有多个重载版本，最常用的两个版本如下：

template< class RandomIt >
void sort( RandomIt first, RandomIt last );

template< class RandomIt, class Compare >
void sort( RandomIt first, RandomIt last, Compare comp );

参数说明

• first: 指向要排序范围的起始迭代器。
• last: 指向要排序范围的结束迭代器（不包括该位置）。
• comp: 比较函数对象，用于自定义排序规则。

默认排序

默认情况下，std::sort 使用 < 运算符对元素进行升序排序。例如：

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    // 使用 std::sort 进行排序
    std::sort(vec.begin(), vec.end());

    // 输出排序后的数组
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

自定义排序

可以通过提供自定义比较函数来实现自定义排序规则。例如，按降序排序：

#include <algorithm>
#include <vector>
#include <iostream>

bool compare(int a, int b) {
    return a > b;
}

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    // 使用 std::sort 进行排序，并指定自定义比较函数
    std::sort(vec.begin(), vec.end(), compare);

    // 输出排序后的数组
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

使用 Lambda 表达式

C++11 引入了 Lambda 表达式，可以更简洁地定义比较函数：

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    // 使用 Lambda 表达式作为自定义比较函数进行排序
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a > b;
    });

    // 输出排序后的数组
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

工作原理

std::sort 通常使用的是一种改进的快速排序算法，在某些情况下会切换到堆排序或插入排序，以保证最坏情况下的时间复杂度为 O(N log N)。

使用注意事项

1. 迭代器必须是随机访问迭代器，例如指向数组或 std::vector 的迭代器。
2. 要确保排序范围内的所有元素是可比较的，且比较操作是对称的。
3. std::sort 是一个就地排序算法，会直接修改容器中的元素。

通过 std::sort 函数，C++ 能够以简洁而高效的方式对容器中的元素进行排序，适用于各种复杂的排序需求。

二者对比

qsort 和 std::sort 是 C 和 C++ 标准库中提供的排序函数，分别用于 C 和 C++ 编程语言。虽然它们的基本功能相似，都是用来对数组或容器进行排序，但在设计和使用上有显著的区别。下面是对这两个函数的详细对比：

1. 所属库

• qsort: 属于 C 标准库，定义在 <stdlib.h> 头文件中。
• std::sort: 属于 C++ 标准库，定义在 <algorithm> 头文件中。

2. 参数类型

• qsort:

  • 使用 void * 指针来处理数组，适用于任意类型的数组。
  • 需要显式传递元素的大小（size_t size）。
  • 使用函数指针作为比较函数（int (*compar)(const void *, const void *)）。

• std::sort:

  • 使用迭代器来表示排序范围，通常用于 STL 容器（如 std::vector、std::array）。
  • 不需要传递元素大小。
  • 默认使用 < 运算符进行排序，也可以使用函数对象或 Lambda 表达式自定义比较函数。

3. 类型安全

• qsort:

  • 类型不安全，需要手动转换 void * 指针，容易出错。
  • 用户需要确保比较函数中的类型转换正确。

• std::sort:

  • 类型安全，使用模板和迭代器，自动推断类型。
  • 比较函数直接使用实际类型，编译器可以进行类型检查。

4. 性能

• qsort:

  • 由于使用 void * 指针和函数指针，存在函数调用的开销。
  • 相对较慢，尤其是对于复杂数据类型。

• std::sort:

  • 使用内联函数和模板，编译器可以进行优化。
  • 通常比 qsort 快，特别是对于内置类型和简单的比较操作。

5. 可扩展性

• qsort:

  • 固定的接口和实现，扩展性差。
  • 适用于简单的排序需求，缺乏灵活性。

• std::sort:

  • 非常灵活，可以排序几乎任何类型的容器。
  • 支持自定义比较函数，甚至可以使用 Lambda 表达式。

6. 使用示例

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]);
    }
    printf("\n");

    return 0;
}

std::sort 示例

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    std::sort(vec.begin(), vec.end());

    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

总结

• 语言适用性：qsort 适用于 C 语言，而 std::sort 专为 C++ 设计，充分利用了模板和迭代器的优势。
• 类型安全性：std::sort 提供了更好的类型安全性和编译时检查。
• 性能：std::sort 通常性能更好，特别是在排序复杂数据类型时。
• 灵活性和可扩展性：std::sort 更加灵活，支持自定义比较函数，使用方便。

在 C++ 开发中，std::sort 是推荐的排序函数，因为它提供了更好的类型安全性和性能，同时更加灵活和易于使用。

cmp比较函数详细对比

qsort 和 std::sort 都依赖于比较函数来确定排序的顺序，但它们的比较函数在使用和定义上有所不同。以下是对这两种比较函数的详细对比：

qsort 的比较函数

qsort 的比较函数需要遵循特定的函数签名，并且参数是 void * 类型的指针，需要在函数内部进行类型转换。以下是 qsort 比较函数的详细介绍：

函数签名

int compar(const void *a, const void *b);

参数和返回值

• 参数:
  • const void *a: 指向要比较的第一个元素。
  • const void *b: 指向要比较的第二个元素。
• 返回值:
  • 如果 a 小于 b，返回负值。
  • 如果 a 等于 b，返回 0。
  • 如果 a 大于 b，返回正值。

示例代码

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

int compare(const void *a, const void *b) {
    int int_a = *((int*)a);
    int int_b = *((int*)b);

    if ( int_a == int_b ) return 0;
    else if ( int_a < int_b ) return -1;
    else return 1;
}

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]);
    }
    printf("\n");

    return 0;
}

std::sort 的比较函数

std::sort 的比较函数更加灵活，可以使用函数对象、函数指针或 Lambda 表达式。以下是 std::sort 比较函数的详细介绍：

函数签名

bool comp(const Type &a, const Type &b);

参数和返回值

• 参数:
  • const Type &a: 要比较的第一个元素。
  • const Type &b: 要比较的第二个元素。
• 返回值:
  • 如果 a 应该排在 b 之前，返回 true。
  • 否则，返回 false。

示例代码

使用函数指针

#include <algorithm>
#include <vector>
#include <iostream>

bool compare(int a, int b) {
    return a < b;
}

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    std::sort(vec.begin(), vec.end(), compare);

    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

使用 Lambda 表达式

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};

    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a < b;
    });

    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

对比总结

参数类型和类型安全

• qsort:

  • 参数是 void * 类型，需要在比较函数中进行类型转换。
  • 类型不安全，容易出现类型转换错误。

• std::sort:

  • 参数是实际类型的引用，无需进行类型转换。
  • 类型安全，编译器可以进行类型检查。

灵活性和可读性

• qsort:

  • 比较函数需要显式进行类型转换，代码可读性差。
  • 只能使用函数指针作为比较函数。

• std::sort:

  • 可以使用函数指针、函数对象或 Lambda 表达式，代码更简洁和灵活。
  • 比较函数可以直接访问元素的实际类型，代码更直观。

性能

• qsort:

  • 使用函数指针进行比较，有额外的函数调用开销。
  • 相对较慢，尤其是对于复杂数据类型。

• std::sort:

  • 使用模板和内联函数，编译器可以进行优化。
  • 通常比 qsort 更快，尤其是对于内置类型和简单的比较操作。

示例对比

qsort 的比较函数示例

int compare(const void *a, const void *b) {
    int int_a = *((int*)a);
    int int_b = *((int*)b);

    if ( int_a == int_b ) return 0;
    else if ( int_a < int_b ) return -1;
    else return 1;
}

std::sort 的比较函数示例

使用函数指针

bool compare(int a, int b) {
    return a < b;
}

使用 Lambda 表达式

[](int a, int b) {
    return a < b;
}

结论

• qsort 适用于 C 语言，但存在类型不安全和性能较低的问题。
• std::sort 适用于 C++，提供了更好的类型安全性、灵活性和性能。