Question

我的部分任务是将2D数组按升序排序，我无法弄清楚如何在我的生命中进行。

到目前为止我所拥有的：

int Sort2DArray(int A[][COL], unsigned int rowsize, unsigned int colsize)
{
 int i, j, k, temp;
 for (i=0; i<rowsize-1; i++){
     for (k=0; k<colsize; k++){
        for (j=0; j<rowsize-1; j++){
            do  {
             temp = A[k][j];
             A[k][j] = A[k][j+1];
             A[k][j+1] = temp;
            } while (A[k][j]>A[k][j+1]);
        }
     }
 }
}

这将获取一个数组并返回：

3 2 1               1 2 3
5 8 7    ---->>>    5 7 8
4 9 3               3 4 9

但是，我需要它返回：

1 2 3
4 5 6
7 8 9

那么，你们有什么方法可以帮助我吗？谢谢！

编辑：

#include <stdio.h>
#include <stdlib.h>

#define COL 20
#define ROW 20

void PopulateArray2DUnique (int [][COL], unsigned int, unsigned int, int, int);

void DisplayArray2D(int [][COL], unsigned int, unsigned int);

int FindLargest(int [][COL], unsigned int, unsigned int);

int FindColSum(int [][COL], unsigned int, unsigned int, unsigned int);

int Sort2DArray(int [][COL], unsigned int, unsigned int);

int main()
{
 int A[ROW][COL];
 int min=1, max=99;
 unsigned int rowsize, colsize, col_to_sum;

 printf ("Input your desired row and column size: \n");
 scanf ("%u%u", &colsize, &rowsize);

 PopulateArray2DUnique(A, rowsize, colsize, min, max);
 DisplayArray2D(A, rowsize, colsize);
 FindLargest(A, rowsize, colsize);

    printf ("Which column would you like to find sum of?\n");
    scanf ("%d", &col_to_sum);

 FindColSum(A, rowsize, colsize, col_to_sum);
 Sort2DArray(A, rowsize, colsize);
 DisplayArray2D(A, rowsize, colsize);

 return 0;
}

Answer 1

有可能吗？

是的，这是可能的。最重要的是要理解的是，您的排序例程以及您在示例中看到的所有基本排序例程通常都会对一维数组进行排序。 [1] 相同的例程可用于按顺序排序正在尝试2D阵列，但您必须认识到您希望将2D数组作为指向类型的指针（简单的1D数组，例如'int *'）传递给排序函数），而不是作为X元素的指向数组的指针（您的2D数组，例如'int (*)[NCOLS]'）

传递数组的关键是简单地将地址传递给数组中的第一个元素。无论您是将其声明为1D还是2D数组（1），它都是内存中值开始的地址; 和（2）所有数组值都是顺序的。这意味着您可以通过start_address + offset来解决1D或2D阵列中的每个值。

以您的简单冒泡程序为例：

void bubblesort (int *a, size_t n)
{
    size_t i, j;
    int temp;

    for (i = 0; i < n; i++) {
        for (j = 0; j < (n-1); j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = temp;
            }
        }
    }
}

如果您已经声明了一个2D数组（例如int array[][NCOL];，而不是指向指针的类型指针 int **array;），那么您希望按顺序排序只需按如下方式传递起始地址即可调用您的排序例程：

    bubblesort (*array, nelem);

或

    bubblesort (&array[0][0], nelem);

（两者都是等效的，'nelem'是总元素数量）

如果您尝试通过将指针传递给数组来声明您的排序函数（例如bubblesort (int (*array)[NCOL], size_t n);，那么由于使用传统的嵌套循环布局，您将难以立即尝试循环索引，没有简单的方法可以将array[i][j]与array[i+1][0]等进行比较。

以下是将所有内容放在一起的简短示例。仔细看看，如果您有疑问，请告诉我：

#include <stdio.h>
#include <stdlib.h>

#define NCOL 3

void bubblesort (int *a, size_t n);

int main ()
{
    int array[][NCOL] = {{3,2,1},
                         {5,8,7},
                         {4,9,3}};
    int i, j, nrows, nelem;

    nrows = sizeof array/sizeof *array;
    nelem = sizeof array/sizeof **array;

    printf ("\noriginal:\n\n");
    for (i = 0; i < nrows; i++) {
        for (j = 0; j < NCOL; j++)
            printf (" %2d", array[i][j]);
        putchar ('\n');
    }

    bubblesort (*array, nelem);

    printf ("\nsorted:\n\n");
    for (i = 0; i < nrows; i++) {
        for (j = 0; j < NCOL; j++)
            printf (" %2d", array[i][j]);
        putchar ('\n');
    }

    return 0;
}

void bubblesort (int *a, size_t n)
{
    size_t i, j;
    int temp;

    for (i = 0; i < n; i++) {
        for (j = 0; j < (n-1); j++) {
            if (a[j] > a[j + 1]) {
                temp = a[j + 1];
                a[j + 1] = a[j];
                a[j] = temp;
            }
        }
    }
}

<强>输出

$ ./bin/qsort_2d_linear

original:

  3  2  1
  5  8  7
  4  9  3

sorted:

  1  2  3
  3  4  5
  7  8  9

注意：您可以使用标准整数比较函数轻松地使用qsort执行相同的操作并调用qsort (array, nelem, sizeof **array, icompare);

脚注[1]： C中的所有数组都是1D数组，2D数组只是以允许2D索引的方式进行寻址。它仍然是一个类型的顺序块＆＃39;记忆中的价值观。）

Answer 2

我不确定这里是否有最好的方法，不过我要做的是将数组中的每个值存储到一个大的1D数组中，对其进行排序，然后将它们分配给2D数组。

int Sort2DArray(int A[][COL], unsigned int rowsize, unsigned int colsize)
{
    int arraySize = rowsize * colsize;
    int sortingArray[arraySize];
    int i = 0, row, col, temp, prevPos;

    //Fills the sortingArray with all the values in the 2D array
    for (col = 0; col < colsize; ++col) {
        for (row = 0; row < rowsize; ++row) {
            sortingArray[i] = A[row][col];
            ++i;
        }
    }

    //Sorts the 1D array (Insertion Sort)
    for (i = 1; i < arraySize; ++i)
    {
        temp = sortingArray[i];
        prevPos = i - 1;
        while (j >= 0 && sortingArray[prevPos] > temp)
        {
            sortingArray[prevPos+1] = sortingArray[prevPos];
            prevPos = prevPos - 1;
        }
        sortingArray[prevPos + 1] = temp;
    }

    //Writes data back into 2D array
    i = 0;
    for (row = 0; row < rowsize; ++row) {
        for (col = 0; col < colsize; ++col) {
            A[row][col] = sortingArray[i];
            ++i;
        }
    }
}

我希望我对所有这些方面都不会感到困惑，但你明白了。如果你发现任何不正确的信息，请告诉我。

Answer 3

它闻起来像是我的家庭作业，因此，我只会帮助你一点，剩下的就是你自己。

当我对C和我的第一个编程语言非常陌生时，我解决了很多问题，其中一个是这个。

我在这里粘贴的代码取自here，一个我经常使用的网站。

由您来理解算法和程序，并在您的程序中使用它。

#include<stdio.h>

int main( )
{

    int a[][6]={
                {25,64,96,32,78,27},      //Desired solution : {25,27,32,64,78,96},
                {50,12,69,78,32,92}       //                   {50,92,78,12,32,69}
                };
     int i, j, k, temp, temp1 ;

    //Bubble sorting is applieed on one first row while the other row is swapped

     for(j=1;j<6;j++)
     {
          for(i=0; i<5; i++)
          {
                if(a[0][i]>a[0][i+1])
                {
                    temp=a[0][i];
                    a[0][i]=a[0][i+1];
                    a[0][i+1]=temp;

                    temp1 = a[1][i];
                    a[1][i] = a[1][i+1];
                    a[1][i+1]=temp1;
                }
          }
     }

     printf ( "\n\nArray after sorting:\n") ;
     for ( i = 0 ; i <2; i++ )
     {
        for(j=0; j<6; j++)
        {
            printf ( "%d\t", a[i][j] ) ;        //printing sorted array
        }
        printf("\n");
     }
 }

它与网站上的代码有点不同，因为我以前一直习惯在Ubuntu中工作，而Linux从来没有conio.h。另外，如果你生气，只提供在任何地方使用的代码，而不是完成所有的工作，请记住，家庭作业是为了让学生思考，如果我用勺子喂你，目的就会丢失。 / p>

注意：始终发布可以成功编译的完整代码，因为您发布的代码无法编译，因为您尚未声明所有功能。因此，很难理解你的代码。

另外，不要试图欺骗我们，因为您提到的输入没有6，并且您还希望返回6，所以实际上即使您没有编译代码。

是否有可能按升序排序，C中的2D数组？如果是这样，怎么样？

3 个答案: