C/C++的2种排序算法

讲解两种排序

1. 冒泡排序（Bubble Sort）
   - 时间复杂度：O(n^2)
   - 稳定性：稳定
   - 实现简单，但效率较低。

2. 桶排序（Bucket Sort）
    - 时间复杂度：平均情况下O(n + k)，其中k是桶的数量
    - 稳定性：稳定
    - 将数据分布到多个“桶”中，每个桶再进行排序，最后将所有桶中的元素合并。

代码示例

1.冒泡排序

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

C语言

#include <stdio.h>

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

C++

#include <iostream>
using namespace std;

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]) {
                swap(arr[j], arr[j+1]); // 使用C++的swap函数进行交换
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr)/sizeof(arr[0]);
    bubbleSort(arr, n);
    cout << "Sorted array: \n";
    for (int i=0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

2.桶排序

把数分布在桶中

 

在桶里进行排序

C++

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

void bucketSort(std::vector<float> &arr) {
    // Find maximum value in the array to determine range of individual buckets
    float max_value = *std::max_element(arr.begin(), arr.end());

    // Create vector of empty vectors for buckets
    std::vector<std::vector<float>> buckets(arr.size());

    // Distribute input array values into buckets
    for (int i = 0; i < arr.size(); ++i) {
        int index = static_cast<int>(arr[i] / (max_value + 1) * arr.size());
        buckets[index].push_back(arr[i]);
    }

    // Sort each bucket and concatenate results
    int k = 0;
    for (int i = 0; i < buckets.size(); ++i) {
        std::sort(buckets[i].begin(), buckets[i].end());
        for (int j = 0; j < buckets[i].size(); ++j) {
            arr[k++] = buckets[i][j];
        }
    }
}

int main() {
    std::vector<float> arr = {0.78f, 0.17f, 0.39f, 0.26f, 0.72f, 0.94f, 0.21f, 0.12f, 0.23f, 0.68f};

    bucketSort(arr);

    std::cout << "Sorted array is \n";
    for (int i = 0; i < arr.size(); ++i) {
        std::cout << arr[i] << " ";
    }
    return 0;
}

C语言

#include <stdio.h>

void bucketSort(int arr[], int n, int maxValue) {
    // Create a bucket array with size equal to the maximum possible value
    int *bucket = (int *)malloc((maxValue + 1) * sizeof(int));

    // Initialize all elements of bucket array to 0
    for (int i = 0; i <= maxValue; i++) {
        bucket[i] = 0;
    }

    // Store count of each element in the bucket array
    for (int i = 0; i < n; i++) {
        bucket[arr[i]]++;
    }

    // Overwrite the original array with sorted elements
    int pos = 0;
    for (int i = 0; i <= maxValue; i++) {
        while (bucket[i]-- > 0) {
            arr[pos++] = i;
        }
    }

    // Free the allocated memory
    free(bucket);
}

int main() {
    int arr[] = {5, 2, 8, 3, 9, 1, 4, 7, 6};
    int n = sizeof(arr) / sizeof(arr[0]);
    int maxValue = 9; // Maximum possible value in the array

    bucketSort(arr, n, maxValue);

    printf("Sorted array is \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}