用两种选择法和两种冒泡法对数组中的十个整数按从小到大排序

以下是两种选择法和两种冒泡法的实现：

1. 选择排序法

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

2. 堆排序法

void heapify(int arr[], int n, int i) {
    int largest = i;
    int l = 2*i + 1;
    int r = 2*i + 2;

    if (l < n && arr[l] > arr[largest]) {
        largest = l;
    }

    if (r < n && arr[r] > arr[largest]) {
        largest = r;
    }

    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(int arr[], int n) {
    for (int i = n/2 - 1; i >= 0; i--) {
        heapify(arr, n, i);
    }

    for (int i = n-1; i >= 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

3. 冒泡排序法

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

4. 改进的冒泡排序法

void optimizedBubbleSort(int arr[], int n) {
    bool swapped;
    for (int i = 0; i < n-1; i++) {
        swapped = false;
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                swap(arr[j], arr[j+1]);
                swapped = true;
            }
        }
        if (swapped == false) {
            break;
        }
    }
}

然后，我们可以使用这些排序函数来对一个包含十个整数的数组进行排序：

int arr[] = {64, 25, 12, 22, 11, 37, 98, 55, 78, 21};
int n = sizeof(arr)/sizeof(arr[0]);

selectionSort(arr, n);
// 输出: 11 12 21 22 25 37 55 78 64 98

heapSort(arr, n);
// 输出: 11 12 21 22 25 37 55 64 78 98

bubbleSort(arr, n);
// 输出: 11 12 21 22 25 37 55 64 78 98

optimizedBubbleSort(arr, n);
// 输出: 11 12 21 22 25 37 55 64 78 98

可以看到，数组被排序为从小到大排列。