在c ++中对多维数组进行排序

Question

我是编程的初学者，我有一个问题。 我必须创建二维数组[5] [3] ...让我们说这是其中一部分的例子：

1. 2 3 4
2. 7 8 9
3. 5 6 7

然后我必须得到一些行并将其写在旁边：

1. 2 3 4 9
2. 7 8 9 24
3. 5 6 7 18

现在，我必须按此总和对数组进行排序，因此结果如下所示：

1. 7 8 9 24
2. 5 6 7 18
3. 2 3 4 9

我不知道如何实现这一点，这是我的代码：

    #include <iostream>
    #include <time.h>
    using namespace std;


    void tocke(int polje[5][3])
    {
      int vsota;
       srand(time(NULL));
       int sums[5];
for (int i = 0; i < 5; i++)
{
    vsota = 0;
    cout << endl;
    cout << i + 1 << ". ";

    for (int j = 0; j < 3; j++){
        polje[i][j] = (rand() % 10 + 1);
        vsota += polje[i][j];
        sums[i] = vsota;
        cout << polje[i][j] << "  ";
    }
}   
    }

    void urejaj(int polje[5][3])
    {
cout << "\n\n\n\n" << endl;
int sums[5];
int vsota ;
double temp;




for (int i = 0; i < 5; i++)
{
    vsota = 0;
    cout << endl;
    cout << i + 1 << ". ";
    for (int j = 0; j < 3; j++)
    {

        vsota += polje[i][j];
        sums[i] = vsota;

        if (sums[i] < sums[i+1])
        {

            temp = polje[i][j];
            polje[i][j] = polje[i + 1][j];
            polje[i + 1][j] = temp;

        }

        cout << polje[i][j] << " ";

    }cout << sums[i];

    }

    }











   int main()
    {
int polje[5][3];
tocke(polje);
urejaj(polje);
cout << "\n";
system("pause");
return 0;


   }

第一个函数在字段中写入元素，第二个函数对字段进行排序。

Answer 1

通过更改数据结构可以更轻松地解决您的问题。 而不是拥有一个数组数组，有一个结构数组。 结构将包含sum和值数组。

struct Row
{
  int sum;
  std::vector<int> values;
};

Row data[5];

使用此概念，您将按行总和对行进行排序。
您可以轻松地为此编写比较器并使用std::sort ：

bool Compare_Rows(const Row& a, const Row &b)
{
  return a.sum < b.sum;
}

//...
std::sort(&data[0], &data[5], Compare_Rows);

编辑1 - 重载运算符<
您可以通过提供重载运算符来简化并且不需要比较器< ：

struct Row
{
  int sum;
  std::vector<int> values;

  bool operator<(const Row& other)
  {
    return sum < other.sum;
  }
};

排序调用现在变为：

std::sort(&data[0], &data[5]);

Answer 2

万一你仍然迷路，这是完整的程序：

#include <iostream>
#include <ctime>
#include <cstdlib>
#include <iomanip>
using namespace std;

void display_matrix(int**, int, int);
void gen_matrix(int**, int, int);
void gen_matrix_sum(int**, int**, int, int);
void sort_matrix(int**, int**, int, int);

int main()
{
    srand(time(0));
    int m=5, n=3;

    int** my_matrix = (int**)malloc(m*sizeof(int*));
    for (int i=0; i<m; i++) my_matrix[i] = (int*)malloc(n*sizeof(int));
    gen_matrix(my_matrix, m, n);
    display_matrix(my_matrix, m, n);
    cout << endl;

    int** my_matrix_sum = (int**)malloc(m*sizeof(int*));
    for (int i=0; i<m; i++) my_matrix_sum[i] = (int*)malloc((n+1)*sizeof(int));
    gen_matrix_sum(my_matrix_sum, my_matrix, m, n);
    display_matrix(my_matrix_sum, m, n+1);
    cout << endl;

    int** my_matrix_sorted = (int**)malloc(m*sizeof(int*));
    for (int i=0; i<m; i++) my_matrix_sorted[i] = (int*)malloc((n+1)*sizeof(int));
    sort_matrix(my_matrix_sorted, my_matrix_sum, m, n);
    display_matrix(my_matrix_sorted, m, n+1);   
    cout << endl;
}

void display_matrix(int** my_matrix, int m, int n)
{
    for (int i=0; i<m; i++)
    {
        for (int j=0; j<n; j++)
            cout << setw(2) << my_matrix[i][j] << " ";
        cout << endl;
    }
}

void gen_matrix(int** M, int m, int n)
{
    int random_limit = 10;

    for (int i=0; i<m; i++)
        for (int j=0; j<n; j++)
            M[i][j] = rand()%random_limit + 1;
}

void gen_matrix_sum(int** M, int** my_matrix, int m, int n)
{
    int aux[m];

    for (int i=0; i<m; i++)
        aux[i] = 0;

    for (int i=0; i<m; i++)
        for (int j=0; j<n; j++)
        {
            M[i][j] = my_matrix[i][j];
            aux[i] += M[i][j];
        }

    for (int i=0; i<m; i++)
        M[i][n] = aux[i];   
}

void sort_matrix(int** my_matrix_sorted, int** my_matrix, int m, int n)
{
    int v_sum_values[m];

    for (int i=0; i<m; i++)
        v_sum_values[i] = my_matrix[i][n];

    int v[n];   
    int max = v_sum_values[0];
    int index;
    for (int i=0; i<m; i++)
    {

        for (int j=0; j<m; j++)
        {
            if (v_sum_values[j]>max)
            {
                max = v_sum_values[j];
                index = j;
            }
        }
        v_sum_values[index] = -1;
        v[i] = index;   
        max = v_sum_values[i];
    }

    for (int i=0; i<m; i++)
        for (int j=0; j<n+1; j++)
            my_matrix_sorted[i][j] = my_matrix[v[i]][j]; 
}

Answer 3

这是我如何处理这个问题：

编写一个交换函数，在多维数组中切换两行。 就像是：

// columns is the number of columns; ie array[rows][columns]
void swap(int[][] array, const int columns, int switch1, int switch2)
{
    for (int i = 0; i < columns; i++)
        array[switch1][i] ^= array[switch2][i] ^= array[switch1][i] ^ array[switch2][i];
}

然后，编写一个sum函数，它将所有元素添加到一行中。 就像是：

int sumCol(int[][] array, int columns, int index)
{
    int sum = 0;
    for (int i = 0; i < columns; i++)
        sum += array[index][i];
    return sum;
}

最后，编写一个sort函数，它能够使用以下操作对多维数组进行排序：

• 比较两行的总和
• 交换两行

我会根据您的喜好决定使用哪种排序算法。

Answer 4

我必须创建二维数组

我不知道你的意思是什么（你必须从一些输入读取它，或用数字等填充它吗？），但是让我们说你创建一个这样的二维矩阵：

// Just a type alias for the matrix.
template <typename T, std::size_t R, std::size_t C>
using Matrix = std::array<std::array<T, C>, R>;

// Create two dimensional matrix [3][3] of ints.
Matrix<int, 3, 3> matrix = {{ { 2, 3, 4 },
                              { 7, 8, 9 },
                              { 5, 6, 7 } }};

然后，您可以按照降序排列每行的总和，如下例所示。 我已经将std::sort与自定义比较器函数 （使用lambda函数创建）一起使用：

std::sort(std::begin(matrix), std::end(matrix), [] (decltype(*matrix.cbegin())& lhs, decltype(*matrix.cbegin())& rhs) {
    return std::accumulate(std::begin(lhs), std::end(lhs), 0) > std::accumulate(std::begin(rhs), std::end(rhs), 0);
});

而已。

现在让我们输出矩阵：

for (decltype(matrix.size()) row = 0; row != matrix.size(); ++row) {
    std::cout << row + 1 << ". ";
    for (const auto i : matrix[row]) {
        std::cout << i << " ";
    }
    std::cout << std::accumulate(std::begin(matrix[row]), std::end(matrix[row]), 0);
    std::cout << std::endl;
}

实例