Rust 与 C/C++ 特性对比及排序算法实现

总结

• C/C++ 优势在于极致性能、底层控制能力和成熟生态，适合对性能要求苛刻或需直接操作硬件的场景（如操作系统内核、游戏引擎、嵌入式开发）。
• Rust 优势在于内存安全、并发安全和现代工具链，适合对安全性和可维护性要求高的场景（如系统级软件、网络服务、区块链底层）。

两者并非替代关系：C/C++ 是'性能优先'的经典选择，Rust 是'安全与性能兼顾'的现代方案。实际开发中可根据场景需求（如是否需要内存安全、团队技术栈）灵活选择或混合使用（如 Rust 调用 C 库）。

二、数组排序算法

以下是 C、C++、Rust 三种语言中数组排序算法的示例，分别包含手动实现（演示算法逻辑）和标准库函数（实际工程推荐）两种方式，并附关键注释说明。

一、C 语言：数组排序

C 语言标准库提供了 qsort 函数（快速排序的变种），适合工程使用；手动实现以经典的冒泡排序和快速排序为例。

1. 标准库函数 qsort

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

// 比较函数：用于 qsort，规定排序规则（升序）
int compare_ints(const void *a, const void *b) {
    int arg1 = *(const int *)a;
    int arg2 = *(const int *)b;
    if (arg1 < arg2) return -1; // a < b → 升序
    if (arg1 > arg2) return 1;
    return 0;
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

    // 使用标准库 qsort 排序（升序）
    qsort(arr, n, sizeof(int), compare_ints);

    // 输出结果
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // 输出：1 2 5 5 6 9
    }
    return 0;
}

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 quick_sort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high); // 分区并获取基准位置
        quick_sort(arr, low, pi - 1);       // 排序左半部分
        quick_sort(arr, pi + 1, high);      // 排序右半部分
    }
}

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, n - 1); // 调用快速排序

    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]); // 输出：1 2 5 5 6 9
    }
    return 0;
}

二、C++：数组排序

C++ 标准库的 std::sort 是混合排序算法（快速排序 + 堆排序 + 插入排序），效率极高；手动实现以模板化快速排序为例，展示泛型编程。

1. 标准库函数 std::sort

#include <iostream>
#include <algorithm> // 包含 std::sort
#include <vector>    // 示例用 vector（数组同理）

int main() {
    int arr[] = {5, 2, 9, 1, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);

    // 对原生数组排序（升序）
    std::sort(arr, arr + n); // 参数：起始指针、结束指针（左闭右开）

    // 对 vector 排序（效果相同）
    std::vector<int> vec = {5, 2, 9, 1, 5, 6};
    std::sort(vec.begin(), vec.end());

    // 输出结果
    for (int num : arr) {
        std::cout << num << " "; // 输出：1 2 5 5 6 9
    }
    return 0;
}

2. 手动实现：模板化快速排序（泛型）

#include <iostream>
using namespace std;

// 交换模板函数（支持任意可复制类型）
template<typename T>
void swap(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

// 分区函数（模板化）
template<typename T>
int partition(T arr[], int low, int high) {
    T 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);
}

// 快速排序递归函数（模板化）
template<typename T>
void quick_sort(T arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);
        quick_sort(arr, low, pi - 1);
        quick_sort(arr, pi + 1, high);
    }
}

int main() {
    int int_arr[] = {5, 2, 9, 1, 5, 6};
    double double_arr[] = {3.14, 1.618, 2.718, 0.5};
    int n1 = sizeof(int_arr) / sizeof(int_arr[0]);
    int n2 = sizeof(double_arr) / sizeof(double_arr[0]);

    quick_sort(int_arr, 0, n1 - 1);
    quick_sort(double_arr, 0, n2 - 1);

    cout << "Sorted int array: ";
    for (int i = 0; i < n1; i++) cout << int_arr[i] << " "; // 1 2 5 5 6 9
    cout << "\n";
    cout << "Sorted double array: ";
    for (int i = 0; i < n2; i++) cout << double_arr[i] << " "; // 0.5 1.618 2.718 3.14
    return 0;
}

三、Rust：数组排序

Rust 标准库的 sort（稳定排序）和 sort_unstable（非稳定但更快）是高度优化的混合排序；手动实现以快速排序为例，利用 Rust 的所有权和切片特性。

1. 标准库函数 sort 和 sort_unstable

fn main() {
    let mut arr = [5, 2, 9, 1, 5, 6];

    // 稳定排序（相等元素的相对顺序不变）
    arr.sort(); // 升序

    // 非稳定排序（更快，适合不关心相等元素顺序的场景）
    // arr.sort_unstable();

    println!("{:?}", arr); // 输出：[1, 2, 5, 5, 6, 9]
}

2. 手动实现：快速排序（利用切片）

fn quick_sort<T: Ord>(arr: &mut [T]) {
    if arr.len() <= 1 {
        return; // 空或单元素数组无需排序
    }
    let pivot_idx = partition(arr);
    let (left, right) = arr.split_at_mut(pivot_idx);
    quick_sort(left);  // 排序左半部分（不包含基准）
    quick_sort(right); // 排序右半部分（包含基准，但已处理）
}

// 分区函数（返回基准的最终位置）
fn partition<T: Ord>(arr: &mut [T]) -> usize {
    let pivot_idx = arr.len() - 1; // 选择最后一个元素为基准
    let mut i = 0;                 // 小于基准的元素的右边界
    for j in 0..pivot_idx {
        if arr[j] <= arr[pivot_idx] {
            arr.swap(i, j); // 交换到左半部分
            i += 1;
        }
    }
    arr.swap(i, pivot_idx); // 将基准放到正确位置
    i                       // 返回基准的索引
}

fn main() {
    let mut int_arr = [5, 2, 9, 1, 5, 6];
    let mut str_arr = ["banana", "apple", "cherry", "date"];

    quick_sort(&mut int_arr);
    quick_sort(&mut str_arr);

    println!("{:?}", int_arr); // 输出：[1, 2, 5, 5, 6, 9]
    println!("{:?}", str_arr); // 输出：["apple", "banana", "cherry", "date"]
}

总结