如何对二维数组的列进行排序？

Question

大家好，我想对二维数组的列进行排序。我想从用户那里获取数组的维度和元素并将其显示为矩阵。 然后减去同一个数组的排序形式。 我们只需要对数组的列进行排序。 请帮忙。

类似的东西

{{0, 1, 3},
{6, 0, 8},
{5, 9, 2}}


{{0, 0, 2},
{5, 1, 3},
{6, 9, 8}}

为此，我在 C ++ 中编写了代码，我可以对数组的第一列进行排序并显示它，但我不能做其他列。 为此我向你呼吁。

#include <iostream>
using namespace std;
int main()
{
    int column, row;
    cout << "Column = ";
    cin >> column;
    cout << "Row = ";
    cin >> row;
    int array[column][row];
    int sortedarray[column];
    for (int z = 0; z < column; z++) {
        for (int a = 0; a < row; a++) {
            cin >> array[z][a];
        }
    }
    for (int i = 0; i < column; i++) {
        sortedarray[i] = array[i][0];
    }

    cout << "\n";
    for (int y = 0; y < column; y++) {
        for (int i = 0; i < row; i++) {
            cout << array[y][i] << "    ";
        }
        cout << endl;
    }
    cout << "\n";

    int temp = 0;
    for (int i = 1; i < column; i++)
        for (int j = 0; j < column - i; j++) {
            if (sortedarray[j] > sortedarray[j + 1]) {
                temp = sortedarray[j];
                sortedarray[j] = sortedarray[j + 1];
                sortedarray[j + 1] = temp;
            }
        }
    cout << "COUT sorted array \n ";
    for (int i = 0; i < column; i++) {
        cout << sortedarray[i] << "  ";
    }
}

Answer 1

据我了解，您需要以下内容：

1 5 6

2 8 4

9 7 3

被分类为：

1 2 3

4 5 6

7 8 9

最简单的方法是您必须将二维数组 map 转换为一维数组 - “1 5 6 2 8 4 9 7 3”，使用最佳算法对它们进行排序。 这将返回“1 2 3 4 5 6 7 8 9”，然后将 map 从一维数组返回到二维数组。

实际上，您可以实现任何排序，这仅取决于您的映射。

你甚至可以实现这样的目标

1 4 7

2 5 8

3 6 9

您需要的是从二维到一维的映射。

Answer 2

@Farhad 您可以将二维数组转换为一维数组，如下所示：

array_1d = array_2d.flatten()

打印（array_1d）

希望这会有所帮助！

Answer 3

#将二维数组转换为一维数组，如下所示：

array_1d = array_2d.flatten()

打印（array_1d）

Answer 4

这是我的解决方案：

#include <iostream>
#include <iomanip>
#include <vector>
#include <tuple>


int getDigitCount( int num )
{
    num = abs( num );

    return ( num < 10    ? 1 :
           ( num < 100    ? 2 :
           ( num < 1000    ? 3 :
           ( num < 10'000   ? 4 :
           ( num < 100'000   ? 5 :
           ( num < 1'000'000  ? 6 :
           ( num < 10'000'000  ? 7 :
           ( num < 100'000'000  ? 8 :
           ( num < 1'000'000'000 ? 9 :
                                    10 )))))))));
}

void printMatrix( const std::vector<int>& array,
                 const std::tuple< const size_t, const size_t >& dimensions, const int maxDigitCount )
{
    std::cout << '\n' << "    \\ Column  ";

    for ( size_t colNumber = 0; colNumber < std::get<1>( dimensions ); ++colNumber )
    {
        std::cout << std::left << std::setw( maxDigitCount + 2 ) << std::setfill(' ') << colNumber;
    }

    std::cout << '\n' << "Row  \\" << '\n' << '\n';

    for ( size_t idx = 0; idx < std::get<0>( dimensions ) * std::get<1>( dimensions ); ++idx )
    {
        if ( ( idx ) % ( std::get<1>( dimensions ) ) == 0 )
        {
            std::cout << " " << ( idx ) / ( std::get<1>( dimensions ) ) << "            ";
        }

        std::cout << std::left << std::setw( maxDigitCount + 2 ) << std::setfill(' ') << array[ idx ];

        if ( ( idx + 1 ) % ( std::get<1>( dimensions ) ) == 0 )
        {
            std::cout << '\n' << '\n';
        }
    }
}

int main()
{
    int inputRowCount { };
    int inputColCount { };

    // get row count and column count from the user

    do
    {
        std::cout << "Enter row count: ";
        std::cin >> inputRowCount;

        std::cout << "Enter column count: ";
        std::cin >> inputColCount;

    } while ( inputRowCount < 1 || inputColCount < 1 );

    const size_t rowCount { static_cast<unsigned int>( inputRowCount ) };
    const size_t colCount { static_cast<unsigned int>( inputColCount ) };
    const size_t elementCount { rowCount * colCount };

    std::vector<int> array( elementCount ); // the 1D array for storing the user's matrix

    // get user input ( user's matrix ) and populate the array

    int maxDigitCount { };

    for ( std::vector<int>::iterator it = array.begin( ); it != array.end( ); ++it )
    {
        std::cin >> *it;

        if ( getDigitCount( *it ) > maxDigitCount )
        {
            maxDigitCount = getDigitCount( *it );
        }
    }

    std::cout << "\nOriginal 2D array:\n"; // print out the array

    printMatrix( array, std::make_tuple< const size_t, const size_t >
                ( std::move( rowCount ), std::move( colCount ) ), maxDigitCount );

    // bubble sort the array

    for ( size_t iterCount = 0; iterCount < elementCount - 1; ++iterCount )
    {
        for ( size_t idx = 0; idx < ( elementCount - 1 - iterCount  ); ++idx )
        {
            if ( array[ idx ] > array[ idx + 1 ] )
            {
                int temp = array[ idx ];
                array[ idx ] = array[ idx + 1 ];
                array[ idx + 1 ] = temp;
            }
        }
    }

    std::cout << "\nSorted 2D array:\n"; // print out the sorted array

    printMatrix( array, std::make_tuple< const size_t, const size_t >
                ( std::move( rowCount ), std::move( colCount ) ), maxDigitCount );

    // transpose 1D array and store in 1D transposedArray

    size_t row { };
    size_t col { };

    std::vector<int> transposedArray( elementCount );

    for ( size_t idx = 0; idx < elementCount; ++idx )
    {
        if ( col == colCount )
        {
            ++row;
            col = 0;
        }

        size_t newIdx { row + ( col * rowCount ) };

        transposedArray[ newIdx ] = array[ idx ];

        ++col;
    }

    std::cout << "\nTransposed sorted 2D array:\n"; // print out the transposed sorted array

    printMatrix( transposedArray, std::make_tuple< const size_t, const size_t >
                ( std::move( colCount ), std::move( rowCount ) ), maxDigitCount );

    return 0;
}

还有一个样品 output：

Enter row count: 5
Enter column count: 4
1  6  11  16
2  7  12  17
3  8  13  18
4  9  14  19
5  10 15  20

Original 2D array:

    \ Column  0   1   2   3
Row  \

 0            1   6   11  16

 1            2   7   12  17

 2            3   8   13  18

 3            4   9   14  19

 4            5   10  15  20


Sorted 2D array:

    \ Column  0   1   2   3
Row  \

 0            1   2   3   4

 1            5   6   7   8

 2            9   10  11  12

 3            13  14  15  16

 4            17  18  19  20


Transposed sorted 2D array:

    \ Column  0   1   2   3   4
Row  \

 0            1   5   9   13  17

 1            2   6   10  14  18

 2            3   7   11  15  19

 3            4   8   12  16  20

转置的排序二维数组是您想要获得的 output （基于我对您问题的理解）。

此外，顶部有两个函数， getDigitCount用于计算一个数字在所有用户提供的数字之间的最大位数以用于格式化目的（使用 std::setw）和另一个 function printMatrix用于打印矩阵。

我希望这个程序能产生你需要的结果。