C++编写常见排序算法、冒泡、选择、插入、希尔、归并排序

1、冒泡排序算法

// 冒泡排序算法
// arr: 需要排序的数组
// n: 数组的大小
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]) {  // 如果当前元素大于后一个元素
                std::swap(arr[j], arr[j + 1]);  // 交换当前元素和后一个元素
            }
        }
    }
}

2、选择排序算法

// 选择排序算法
// arr: 需要排序的数组
// n: 数组的大小
void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {  // 遍历数组的每一个元素
        int min_index = i;  // 保存当前元素的最小索引

        for (int j = i + 1; j < n; j++) {  // 遍历数组的每一个元素，从后向前遍历
            if (arr[j] < arr[min_index]) {  // 如果当前元素小于最小索引元素
                min_index = j;  // 更新最小索引元素的索引
            }
        }
        std::swap(arr[min_index], arr[i]);  // 将最小索引元素和当前元素交换位置
    }
}

3、插入排序算法

// 插入排序算法
// arr: 需要排序的数组
// n: 数组的大小
void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {  // 遍历数组的每一个元素
        int key = arr[i];  // 保存当前元素
        int j = i - 1;  // 保存当前元素的前一个元素的索引
        while (j >= 0 && arr[j] > key) {  // 遍历数组的每一个元素，从前向后遍历
            arr[j + 1] = arr[j];  // 将当前元素向右移动一位
            j--;  // 前一个元素的索引向左移动一位
        }
        arr[j + 1] = key;  // 将当前元素插入到正确的位置
    }
}

4、希尔排序算法

// 希尔排序算法
// arr: 需要排序的数组
// n: 数组的大小
void shellSort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {  // 遍历数组的每一个元素
        for (int i = gap; i < n; i++) {  // 遍历数组的每一个元素
            int key = arr[i];  // 保存当前元素
            int j = i - gap;  // 保存当前元素的前一个元素的索引
            while (j >= 0 && arr[j] > key) {  // 遍历数组的每一个元素，从前向后遍历
                arr[j + gap] = arr[j];  // 将当前元素向右移动 gap 位
                j -= gap;  // 前一个元素的索引向左移动 gap 位
            }
            arr[j + gap] = key;  // 将当前元素插入到正确的位置
        }
    }
}

5、归并排序算法

// 归并排序算法
// arr: 需要排序的数组
// l: 数组的起始索引
// r: 数组的结束索引
void merge(int arr[], int l, int m, int r) {
    int n1 = m - l + 1;  // 子数组 A 的大小
    int n2 = r - m;  // 子数组 B 的大小
    // 创建两个子数组
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++) {  // 遍历子数组 A
        L[i] = arr[l + i];  // 将子数组 A 的元素复制到 L 数组中
    }
    for (int j = 0; j < n2; j++) {  // 遍历子数组 B
        R[j] = arr[m + 1 + j];  // 将子数组 B 的元素复制到 R 数组中
    }
    // 初始化两个子数组的索引
    int i = 0, j = 0;
    // 将子数组 A 和子数组 B 合并到 arr 中
    for (int k = l; k <= r; k++) {  // 遍历 arr
        if (i < n1 && j < n2) {  // 如果子数组 A 和子数组 B 中还有元素
            if (L[i] <= R[j]) {  // 如果子数组 A 的元素小于等于子数组 B 的元素
                arr[k] = L[i];  // 将子数组 A 的元素复制到 arr 中
                i++;  // 子数组 A 的索引向右移动一位
            } else {  // 如果子数组 A 的元素大于子数组 B 的元素
                arr[k] = R[j];  // 将子数组 B 的元素复制到 arr 中
                j++;  // 子数组 B 的索引向右移动一位
            }
        } else if (i < n1) {  // 如果子数组 A 中还有元素
            arr[k] = L[i];  // 将子数组 A 的元素复制到 arr 中
            i++;  // 子数组 A 的索引向右移动一位
        } else {  // 如果子数组 B 中还有元素
            arr[k] = R[j];  // 将子数组 B 的元素复制到 arr 中
            j++;  // 子数组 B 的索引向右移动一位
        }
    }
}