若二维数组a有m列，则a【i】【j】前面的元素个数

如果一个二维数组a有m列，我们可以假设二维数组是按行存储的，即第1行的所有元素依次存储在a[0][0]到a[0][m-1]的位置，第2行的所有元素依次存储在a[1][0]到a[1][m-1]的位置，以此类推。

那么a[i][j]前面的元素个数就是i * m + j。因为在按行存储的二维数组中，a[i][j]所在的行之前，共有i行，每行有m个元素，所以前面的元素个数就是i * m。而在a[i][j]所在的行中，a[i][j]前面有j个元素，所以再加上j，就是a[i][j]前面的元素个数了。

相关问题

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

### 回答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 

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

6-17 二维数组：求最大元素及其所在的行坐标及列坐标。 求出N×M整型数组的最大元素及其所在的行坐标及列坐标（如果最大元素不唯一，选择位置在最前面的一个）。

好的，让我来回答你的问题。对于这个问题，我们可以通过遍历二维数组来求解。我们首先假设最大元素为数组的第一个元素，然后依次遍历数组的每一个元素，如果发现某个元素大于当前的最大值，就更新最大值及其所在的行列坐标。

具体的实现可以参考下面的代码示例：

# 定义一个二维数组
arr = [[4, 2, 8], 
       [7, 5, 1],
       [9, 6, 3]]

# 定义最大值、最大值所在行列坐标
max_val = arr[0][0]
max_row, max_col = 0, 0

# 遍历二维数组
for i in range(len(arr)):
    for j in range(len(arr[0])):
        if arr[i][j] > max_val:
            max_val = arr[i][j]
            max_row, max_col = i, j

# 输出结果
print("最大值：", max_val)
print("所在行列坐标：", max_row, max_col)

希望能够帮到你！如果你还有其他问题，请继续提问。