如何按降序打印2D数组的值？

Question

So I have a 2D matrix and I'm trying to print out the values from largest to smallest. I basically do this by always looking for a max and when I find it I set that position equal to 1 in adjacencyMatrix so that we don't count it again. Problem is when I tested the code it started out correctly by printing out the largest and then skipped the second largest. Then found the 3rd and 4th largest. Skipped some more and then finally just started printing out 0s.

Here is my code:

public static void findLongestPath(int rows, int columns, int[][] elevationMatrix, int[][] adjacencyMatrix)
    {
        int max = 0;

        for (int x = 0; x < rows * columns; x++)
        {   
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    if (elevationMatrix[i][j] > max && adjacencyMatrix[i][j] == 0)
                    {
                        max = elevationMatrix[i][j];
                        adjacencyMatrix[i][j] = 1;
                    }
                }
            }

            System.out.println(max);
            max = 0;
        }
    }

I have been staring at it for a while and can't find the bug so I though another pair of eyes might help.

PS Please, please, please don't tell me to sort the array because I can'd do that. I need to maintain the order of the original array.

Answer 1

public static void findLongestPath(int rows, int columns, int[][] elevationMatrix, int[][] adjacencyMatrix)
    {
        int max = 0;
        int cX, cY;

        for (int x = 0; x < rows * columns; x++)
        {   
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    if (elevationMatrix[i][j] > max && adjacencyMatrix[i][j] == 0)
                    {
                        max = elevationMatrix[i][j]; // possible max, xth iteration
                        cX = i; // store i
                        cY = j; // store j
                    }
                }
            }

            System.out.println(max); // global max, xth iteration
            max = 0;
            // cX and cJ now point to coordinates of global max
            // all the possible max value coordinates are ignored.
            adjacencyMatrix[cX][cJ] = 1;
        }
    }

I think you need to set adjacencyMatrix[][] = 1 , after you find largest number throughout the matrix(global max), rather than finding a max(possible max).

There can be more efficient ways to do this, I'm pointing out what needs to be done in this method to work.

Answer 2

public static void findLongestPath(int rows, int columns, int[][] elevationMatrix)
{
   class PosAndValue implements Comparable<PosAndValue> {
     final int x;
     final int y;
     final int value;
     PosAndValue(int x, int y, int value) {
       this.x = x;
       this.y = y;
       this.value = value;
     }
     public int compareTo(PosAndValue other) {
       return Integer.compare(value, other.value);
     }
   }
   PosAndValue[] array = new PosAndValue[rows * columns];
   for (int i = 0; i < rows; i++) {
     for (int j = 0; j < columns; j++) {
       array[i * columns + j] = new PosAndValue(i, j, elevationMatrix[i][j]);
     }
   }
   Arrays.sort(array);
   for (int i = array.length - 1; i >= 0; i--) {
     System.out.println(array[i].value);
   }
}

Answer 3

The problem is you're trying to pseudo-sort it.

Just make a list or 1D array of all the values and sort that. If you declare the temp array in the method, then the garbage collection thread will eventually pick it up.

Your method can be ~10 lines: add all values to the temp array, sort it, print all values.

int[] tempArr = new int[rows * columns];
for(int i = 0; i < rows; i++){
    for(int j = 0; j < columns; j++){
        tempArr[(i * col) + j] = elevationMatrix[i][j];
    }
}
Arrays.sort(tempArr);
for(int x = (rows * columns) - 1; x >= 0; x--){
    System.out.println(tempArr[x]);
}