用指针实现一维数组冒泡排序

void bubble_sort(int* arr, int size) {
    int temp;
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            if (*(arr + j) > *(arr + j + 1)) {
                temp = *(arr + j);
                *(arr + j) = *(arr + j + 1);
                *(arr + j + 1) = temp;
            }
        }
    }
}

使用指针访问数组元素时，可以使用`*(arr + i)`表示`arr[i]`，意义相同。我们可以根据这种方法来实现冒泡排序。首先，外层循环控制比较的轮数，内层循环控制每轮比较的次数。在每轮比较中，如果前一个元素比后一个元素大，就交换它们的位置。交换时需要用到中间变量`temp`。

相关问题

C语言一维数组冒泡排序

C语言一维数组冒泡排序可以通过比较相邻的元素，将较大的元素交换到右侧，从而实现排序。以下是两种不同的实现方法：

方法一：普通冒泡排序

#include <stdio.h>
void main(){
    int a[10],i,j,max;
    for(i=0;i<10;i++){
        printf("请输入%d个数字：",i+1);
        scanf("%d",&a[i]);
    }
    for(i=0;i<10-1;i++){
        for(j=0;j<10-1-i;j++){
            if(a[j]>a[j+1]){
                max=a[j];
                a[j]=a[j+1];
                a[j+1]=max;
            }
        }
    }
    printf("冒泡排序后的顺序为：");
    for(i=0; i<10; i++){
        printf("%d ",a[i]);
    }
}

方法二：指针冒泡排序

#include <stdio.h>
void sort(int *p){
    int i,j,max;
    for(i=0;i<10-1;i++){
        for(j=0;j<10-1-i;j++){
            if(p[j]>p[j+1]){
                max=p[j];
                p[j]=p[j+1];
                p[j+1]=max;
            }
            /*等同于：
            if(*(p+j)>*(p+j+1)){
                max=*(p+j);
                *(p+j)=*(p+j+1);
                *(p+j+1)=max;
            }
            */
        }
    }
}
void main(){
    int *p,a[10],i,j;
    p = a;
    for(i=0;i<10;i++){
        printf("请输入%d个数字：",i+1);
        scanf("%d",p+i);
    }
    sort(p);
    printf("冒泡排序后的顺序为：\n");
    for(i=0; i<10; i++){
        printf("%d ",*(p+i)); // 等同于 *(p++)
    }
}

利用指针实现二维数组从大到小排序输出

### 回答1：
下面是一个使用指针实现二维数组从大到小排序并输出的代码：

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 10;

bool cmp(int *a, int *b) {
    return *a > *b;
}

int main() {
    int a[N][N];
    int *p[N * N];
    int k = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            a[i][j] = rand() % 100;
            p[k++] = &a[i][j];
        }
    }
    sort(p, p + N * N, cmp);
    for (int i = 0; i < N * N; i++) {
        cout << *p[i] << " ";
    }
    cout << endl;
    return 0;
}

这段代码的主要思路是：将二维数组的每一个元素地址存储在指针数组`p`中，然后对指针数组排序，最后通过指针数组输出二维数组的元素。

### 回答2：
要利用指针实现二维数组从大到小排序输出，首先我们需要找到二维数组中的最大值，并记录其位置。然后将最大值与第一个元素交换位置，再找出剩下元素中的最大值，并与第二个元素交换位置，以此类推，直到整个二维数组按照从大到小排列。

具体步骤如下：
1. 定义一个二维数组arr[m][n]，并初始化数组元素。
2. 定义两个指针，一个指向二维数组的元素，另一个指向当前最大值的位置。
3. 使用两层循环遍历整个二维数组，外层循环控制行数，内层循环控制列数。
4. 在内层循环中，比较当前元素与最大值的大小，如果当前元素大于最大值，更新最大值的位置。
5. 完成内层循环后，交换最大值和当前指针指向的元素。
6. 重复以上步骤，直到整个二维数组按照从大到小排序。
7. 最后，按照正确的顺序输出排序后的二维数组。

代码示例：

#include <iostream>

void sortDescending(int* arr, int m, int n) {
  for (int i = 0; i < m * n; ++i) {
    int maxIndex = i;
    for (int j = i + 1; j < m * n; ++j) {
      if (*(arr + j) > *(arr + maxIndex)) {
        maxIndex = j;
      }
    }
    std::swap(*(arr + i), *(arr + maxIndex));
  }
}

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

  int* ptr = &arr[0][0];
  sortDescending(ptr, m, n);

  std::cout << "排序后的二维数组为：" << std::endl;
  for (int i = 0; i < m; ++i) {
    for (int j = 0; j < n; ++j) {
      std::cout << arr[i][j] << " ";
    }
    std::cout << std::endl;
  }

  return 0;
}

以上代码将输出：

9 8 7 
6 5 4 
3 2 1

这就是利用指针实现二维数组从大到小排序输出的方法。

### 回答3：
要利用指针实现二维数组的从大到小排序输出，首先需要明确的是二维数组的内存存储是以行为主的连续存储，即每一行的元素在内存中是连续存储的。

为了方便排序，我们可以使用冒泡排序算法。冒泡排序算法的基本思想是比较相邻的两个元素，如果前面的元素大于后面的元素，则交换两个元素的位置。

具体实现过程如下：

1. 定义一个指向二维数组的指针p，并初始化为数组的首元素的地址。
2. 使用两层循环遍历二维数组的每个元素。外层循环控制行的遍历，内层循环控制列的遍历。
3. 在内层循环中，比较相邻的两个元素的值，如果前面的元素大于后面的元素，则交换它们的位置。
4. 继续进行下一列的遍历，直到所有元素都被比较一遍。
5. 如果一行的元素需要交换位置，将指针p指向下一行的首元素。反之，指针p保持不变。
6. 重复步骤3-5，直到所有行都被遍历一遍。

最后，输出排序后的二维数组。

利用指针实现二维数组从大到小排序输出的代码示例如下：

#include <iostream>
using namespace std;

int main() {
    int a[3][3] = {{3, 2, 1},
                   {6, 5, 4},
                   {9, 8, 7}};
    int (*p)[3] = a;  // 定义指向二维数组的指针，指向首行的地址

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 3; k++) {
                // 比较相邻的两个元素的值，如果前面的元素大于后面的元素，则交换它们的位置
                if (*(p[j] + k) < *(p[j + 1] + k)) {
                    int temp = *(p[j] + k);
                    *(p[j] + k) = *(p[j + 1] + k);
                    *(p[j + 1] + k) = temp;
                }
            }
        }
    }

    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            cout << *(p[i] + j) << " ";
        }
        cout << endl;
    }

    return 0;
}

上述代码实现了对一个3x3的二维数组进行从大到小的排序，并输出排序后的结果。输出结果为：

9 8 7 
6 5 4 
3 2 1 

以上是利用指针实现二维数组从大到小排序输出的方法。