c++任意整数N个元素数组排序

可以使用STL中的sort函数来对任意整数N个元素的数组进行排序，以下是一个示例代码：

#include <iostream>
#include <algorithm>

using namespace std;

int main()
{
    int arr[] = {5, 2, 9, 3, 7, 1, 8, 6, 4};
    int n = sizeof(arr) / sizeof(int);

    sort(arr, arr + n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

其中，sort函数的第一个参数是待排序数组的起始地址，第二个参数是待排序数组的结束地址（注意不是数组元素个数），这里使用了指针加法来计算结束地址；如果要按照从大到小的顺序排序，可以使用sort函数的第三个参数，如下所示：

sort(arr, arr + n, greater<int>());

相关问题

C++ 用选择法对任意 10个整数从小到大排序。。

下面是使用选择排序算法对10个整数从小到大排序的C++代码：

#include <iostream>
using namespace std;

void selectionSort(int arr[], int n);

int main() {
    int arr[10] = {9, 5, 7, 2, 4, 1, 8, 6, 10, 3};

    selectionSort(arr, 10);

    cout << "Sorted array: ";
    for(int i = 0; i < 10; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

void selectionSort(int arr[], int n) {
    int i, j, min_idx;
    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;
            }
        }
        swap(arr[min_idx], arr[i]);
    }
}

在这个代码中，我们定义了一个名为`selectionSort`的函数，该函数接受一个整数数组和数组的大小作为参数，并使用选择排序算法对数组进行排序。在主函数中，我们定义了一个包含10个整数的数组，并将其作为参数传递给`selectionSort`函数进行排序。最后，我们输出已排序的数组。

用C++写一个冒泡排序算法

### 回答1：
好的，这是用 C 语言写的冒泡排序算法：

void bubble_sort(int *array, int length) {
  int i, j, temp;
  for (i = 0; i < length - 1; i++) {
    for (j = 0; j < length - 1 - i; j++) {
      if (array[j] > array[j + 1]) {
        temp = array[j];
        array[j] = array[j + 1];
        array[j + 1] = temp;
      }
    }
  }
}

冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

上面的代码中，函数 `bubble_sort()` 接收两个参数：一个整型数组和这个数组的长度。内部有两个循环，外层循环控制比较的轮数，内层循环控制每轮比较的次数。每轮比较时，如果前一个数比后一个数大，就交换它们的位置。

### 回答2：
冒泡排序是一种简单的排序算法，基本思想是重复地走访要排序的数列，一次比较相邻两个元素，如果顺序不对则交换。通过多次的遍历，将最大的元素逐渐移至最后，直至整个数列有序。

以下是用C语言实现冒泡排序算法的代码：

#include <stdio.h>

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]) {
                // 交换相邻两个元素
                int 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("排序后的数组：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    
    return 0;
}

以上代码中，`bubbleSort`函数接受一个整数数组和数组的长度作为参数，在函数内部使用两个嵌套的循环遍历数组，并比较相邻两个元素的大小。如果前一个元素大于后一个元素，则交换它们的位置。最外层的循环控制遍历的轮数，每一轮都会将最大的元素沉到最后。最后，`main`函数中调用`bubbleSort`函数进行排序，并输出结果。

使用以上代码，可以针对任意长度的数组进行冒泡排序，实现从小到大的排序结果。

### 回答3：
冒泡排序是一种简单的排序算法，用于将一个列表按照升序或降序重新排列。

该算法的基本思想是，从列表的第一个元素开始，比较它和它后面的元素，如果前面的元素大于后面的元素，则交换它们的位置，这样较大的元素就会逐渐“浮”到列表的末尾。然后再针对列表的剩余元素重复以上步骤，直到整个列表都排好序为止。

以下是用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 - 1 - i; j++) { // 内层循环进行元素比较和交换
if (arr[j] > arr[j + 1]) { // 比较相邻两个元素的大小
temp = arr[j]; // 如果前面的元素大于后面的元素，则交换它们的位置
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

int main() {
int arr[] = {5, 2, 8, 1, 6};
int n = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, n);
printf("排序后的结果：");
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
return 0;
}

以上程序的输出结果为：1 2 5 6 8，表示列表已按照升序排列好了。

冒泡排序的时间复杂度为O(n^2)，在处理大规模的数据时，效率相对较低。因此，它主要适用于数据量较小的排序需求。