冒泡排序（Bubble Sort）

原理：

冒泡排序是一种简单的排序算法，它重复地遍历待排序的列表，比较每对相邻元素，如果它们的顺序错误就把它们交换过来。遍历列表的工作是重复进行的，直到没有再需要交换的元素为止，这意味着列表已经排序完成。

步骤：

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

算法复杂度：

• 最好情况（已经排序）：O(n)
• 平均情况：O(n^2)
• 最坏情况（逆序）：O(n^2)

代码示例（C语言）：

void bubbleSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n-1; i++)     
        for (j = 0; j < n-i-1; j++)
            if (arr[j] > arr[j+1])
                swap(&arr[j], &arr[j+1]);
}

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

选择排序（Selection Sort）

原理：
选择排序是一种简单直观的排序算法。它的工作原理是每次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

步骤：

1. 找到数组中最小元素的索引。
2. 将找到的最小元素和数组的第一个元素交换。
3. 从数组的第二个元素开始，重复第一步和第二步，直到数组的末尾。

算法复杂度

• 最好、最坏和平均情况：O(n^2)

代码示例（C语言）

void selectionSort(int arr[], int n) {
    int i, j, min_idx, temp;

    // 移动未排序数组的边界
    for (i = 0; i < n-1; i++) {
        // 找到未排序部分的最小元素的索引
        min_idx = i;
        for (j = i+1; j < n; j++) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }

        // 交换找到的最小元素与当前位置的元素
        temp = arr[min_idx];
        arr[min_idx] = arr[i];
        arr[i] = temp;
    }
}

快速排序（Quick Sort）

原理：
快速排序是一种分而治之的排序算法，它通过一个轴点将数据分为两部分，对左右两部分递归进行快速排序。

步骤：

1. 选择一个元素作为“轴点”（pivot）。
2. 重新排列数组，所有比轴点值小的元素摆放在轴点前面，所有比轴点值大的元素摆在轴点后面（相同的数可以到任一边）。在这个分区退出之后，该轴点就处于集合的中间位置。
3. 递归地将小于轴点元素的子数组和大于轴点元素的子数组排序。

算法复杂度：

• 最好情况：O(n log n)
• 平均情况：O(n log n)
• 最坏情况：O(n^2)

代码示例（C语言）：

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);
    }
}

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 swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

区别

1. 时间复杂度：

   • 冒泡排序和选择排序在最坏和平均情况下都是 O(n^2)，而快速排序在平均情况下是 O(n log n)，更高效。

2. 空间复杂度：

   • 冒泡排序和选择排序都是 O(1)，而快速排序是 O(log n)，因为递归调用需要栈空间。

3. 稳定性：

   • 冒泡排序是稳定的排序算法，而选择排序和快速排序是不稳定的。

4. 原地排序：

   • 冒泡排序和选择排序都是原地排序，不需要额外的存储空间。快速排序通常也是原地排序，但快速排序的某些实现可能需要额外的空间。

5. 最佳应用场景：

   • 冒泡排序和选择排序适合小数据集或基本有序的数据集。
   • 快速排序适合大数据集，因为它的平均性能更好。

在实际应用中，选择哪种排序算法取决于数据的特性和算法的性能要求。