王道OJ课时16作业，冒泡、快速、插入排序

Description

读取10个整型数据12 63 58 95 41 35 65  0 38 44，然后通过冒泡排序，快速排序，插入排序，分别对该组数据进行排序，输出3次有序结果，每个数的输出占3个空格

Input

12 63 58 95 41 35 65  0 38 44

Output

输出3次有序结果

0 12 35 38 41 44 58 63 65 95

0 12 35 38 41 44 58 63 65 95

0 12 35 38 41 44 58 63 65 95

Sample Input 1 

12 63 58 95 41 35 65  0 38 44

Sample Output 1

  0 12 35 38 41 44 58 63 65 95
  0 12 35 38 41 44 58 63 65 95
  0 12 35 38 41 44 58 63 65 95

#include <stdio.h>

// 交换两个整数的值
void swap(int &a, int &b) {
    int temp;
    temp = a; // 保存a的值
    a = b;    // 将b的值赋给a
    b = temp; // 将a原来的值赋给b
}

// 冒泡排序算法，对数组的指定区间进行排序
void bubbleSort(int array[], int l, int r) {
    for (int i = l; i < r; ++i) {
        bool isSorted = true; // 标记数组是否已经排序
        for (int j = r; j > i; --j) {
            if (array[j] < array[j - 1]) { // 如果前一个元素大于后一个元素，交换它们
                swap(array[j], array[j - 1]);
                isSorted = false; // 发生了交换，数组可能未排序
            }
        }
        if (isSorted) { // 如果没有发生交换，说明数组已经排序
            break;
        }
    }
}

// 快速排序中的分区操作，返回枢轴的最终位置
int partition(int array[], int l, int r) {
    int pivot = array[r]; // 选择最右侧的元素作为枢轴
    int i = l - 1; // i指针用于跟踪比枢轴小的元素的最右侧位置

    for (int j = l; j <= r - 1; j++) { // 遍历除了枢轴外的所有元素
        if (array[j] < pivot) { // 如果当前元素小于枢轴
            i++; // 移动i指针
            swap(array[i], array[j]); // 交换元素使得小于枢轴的元素都在左侧
        }
    }
    swap(array[i + 1], array[r]); // 将枢轴元素移动到正确的位置
    return (i + 1); // 返回枢轴元素的最终位置
}

// 快速排序算法，对数组的指定区间进行排序
void quickSort(int array[], int l, int r) {
    if (l < r) {
        int pivotPos;
        pivotPos = partition(array, l, r); // 对数组进行分区，并获取枢轴的位置
        quickSort(array, l, pivotPos - 1); // 对枢轴左边的数组进行快速排序
        quickSort(array, pivotPos + 1, r); // 对枢轴右边的数组进行快速排序
    }
}

// 插入排序算法，对数组的指定区间进行排序
void insertSort(int array[], int l, int r) {
    for (int i = l + 1; i <= r; ++i) {
        for (int j = i; j > 0; --j) {
            if (array[j] < array[j - 1]) { // 如果当前元素小于前一个元素，交换它们
                swap(array[j], array[j - 1]);
            } else { // 否则，说明找到了正确的位置
                break;
            }
        }
    }
}

int main() {

    const int MAX_SIZE = 10; // 定义数组的最大大小

    int array[MAX_SIZE]; // 原始数组
    int array1[MAX_SIZE]; // 用于冒泡排序的数组
    int array2[MAX_SIZE]; // 用于快速排序的数组
    int array3[MAX_SIZE]; // 用于插入排序的数组

    // 读入数据，并复制到三个数组中
    for (int i = 0; i < MAX_SIZE; ++i) {
        scanf("%d", &array[i]);
        array1[i] = array2[i] = array3[i] = array[i];
    }

    // 对array1使用冒泡排序
    bubbleSort(array1, 0, MAX_SIZE - 1);

    // 打印冒泡排序的结果
    for (int i = 0; i < MAX_SIZE; ++i) {
        printf(" %2d", array1[i]);
    }
    printf("\n");

    // 对array2使用快速排序
    quickSort(array2, 0, MAX_SIZE - 1);

    // 打印快速排序的结果
    for (int i = 0; i < MAX_SIZE; ++i) {
        printf(" %2d", array2[i]);
    }
    printf("\n");

    // 对array3使用插入排序
    insertSort(array3, 0, MAX_SIZE - 1);

    // 打印插入排序的结果
    for (int i = 0; i < MAX_SIZE; ++i) {
        printf(" %2d", array3[i]);
    }

    return 0;
}