C++找到矩阵的最小元素和最大元素之间的元素之和

Question

，所以我的程序应尽其所能，但前提是最小和最大元素在相对角。 因此，我的问题是如何从一个特定元素到另一个元素迭代二维阵列（也许可以摆脱一些嵌套的循环）。我可以将此数组转换为一维吗？

在这里是代码的正确工作：

这是出现问题的时候。元素{0} {1}和{1} {1}丢失了。

这是代码的缩短var：

#include <iostream>

using namespace std;

void matrix_count(int a[5][5],int min, int max, int min_i, int min_j, int max_i, int max_j) {
    int suma = 0;
    int counter = 0;
    if (min_i <= max_i && min_j <= max_j) { 
        for (int i = 0; i < 5; i++) {       //iterating all matrix
            for (int j = 0; j < 5; j++) {
                if (a[i][j] == min) {       //start a new cycle when find min
                    for (int i = min_i; i < 5; i++) {
                        for (int j = min_j; j < 5; j++) {
                            if (a[i][j] == max) { i = 5; break; }
                            else if (a[i][j] != min) {
                                counter++;
                                suma += a[i][j];
                                cout << a[i][j] << " ";
                            }
                        }
                    }
                }
            }
        }
    }
    else if (min_i >= max_i && min_j <= max_j) {} // min[i]<max[i] min[j]<max[j]
    else if (min_i <= max_i && min_j >= max_j) {} // min[i]<max[i] min[j]>max[j]
    else if (min_i >= max_i && min_j >= max_j) {} // min[i]>max[i] min[j]>max[j]
    cout << endl;
    cout << suma << endl;
    cout << counter << endl;
}

int main()
{
    int a[5][5] = { 
        {0,4,6,3,5},
        {7,1,5,6,2},
        {6,8,8,5,2},
        {4,1,5,2,2},
        {4,3,6,5,9} };
    int min = a[0][0];
    int max = a[0][0];
    int max_i = 0;
    int min_i = 0;
    int max_j = 0;
    int min_j = 0;

// finding the max
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (a[i][j] > max) {
                max = a[i][j];
                max_i = i;
                max_j = j;
            }
        }
    }

// finding the min
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 5; j++) {
            if (a[i][j] < min) {
                min = a[i][j];
                min_i = i;
                min_j = j;
            }
        }
    }

    matrix_count(a, min, max, min_i, min_j, max_i, max_j);

    return 0;
}

正如我的评论所说，一种解决方案是意识到二维数组在连续内存中具有其数据的布局。  因此，获得最小，最大和总和变得简单，因为您将以与一维数组相同的方式穿越二维阵列。

here是使用C ++算法函数的解决方案。

Answer 1

输出：

100

是的，这是整个代码。

那做了什么？
首先，我们使用

STD::minmax_element

将数组从指针到第一个元素（

&a[0][0]

）到一个元素（一个到一个），传递了最后一个元素（

&a[4][5]

）。 请注意该函数的参数 - 原因是我前面提到的二维数组具有连续的布局。 因此，这只是弄清起点和结束位置的问题。

返回值是一个指向最小元素（

std::minmax_element

）和最大元素（

std::pair<int*, int*>）的指向。 这就是first

表示。
一旦完成，我们可以通过使用

STD:: comgualtules comgualte cluckuleantscomguate

与我们的指针添加最小元素和最大元素之间的项目。

注意，第一个参数是找到最小值之后的下一个值。 这就是在第一个参数中引起

second

的原因 - 它将我们带到了下一个值。

问题是您仅迭代从

pr

到5。在此供语句中：

pr

这意味着

every

线将始于

std::accumulate。 一种解决此问题的简便方法是首先要迭代该行的其余部分，例如：

std::next

然后迭代以下循环剩下的内容：

min_i但总的来说，我真的建议您对您的代码有更多的思考，因为您所做的所有事情都可以通过在整个矩阵中进行一次迭代来完成。另外，直到最小达到最小值的前两个循环不仅令人困惑（您是重复使用J和I），而且是不必要的。您可以直接从上面显示的代码中的

for (int i = min_i; i < 5; i++)

Answer 2

尽管已经给出答案，但我将分享我的个人解决方案，其中我将转换阵列用于一维。

min_i

==任务6收到。添加一个src/matrix_sort.c程序，该程序分类给定 matrix，将最小元素总和排在首先，然后是行具有最大元素总和。该程序的输入数据是数字n

和m - 数字的矩阵尺寸和nxm - 矩阵元素。内存

必须使用3种方法之一动态分配矩阵。和IT

在程序结束时要清除。如果有任何错误，请输出“ n/a”。==

输入输出

1334 3 19 0 55-4 7-10

-4 7 -104 3 19 055

Answer 3