Java Сортировка строк 2d массива по возрастанию и столбцов по убыванию

Question

Пожалуйста, кто-нибудь может мне помочь, мне нужно отсортировать столбцы 2d массива в порядке убывания? Я использовал этот код для сортировки строк массива в порядке возрастания, но теперь мне нужно отсортировать столбцы по убыванию.

// Initialize array
static int[][] sortArray = new int[7][7];

public static void main(String args[]) {
    //initialize array values with random numbers
    for (int i = 0; i < sortArray.length; i++) {
        for (int j = 0; j < sortArray[i].length; j++) {
            sortArray[i][j] = (int) (Math.random() * 100);

        }
    }

    System.out.println("\n" + "Before sorting");
    displayArray();

    //Print out sorted array
    for (int i = 0; i < sortArray.length; i++) {
        bubbleSort(sortArray[i]);
    }

    System.out.println("\n" + "Array rows in ascending order");
    displayArray();

    //Print out sorted columns of array
    for (int i = 0; i < sortArray.length; i++) {
        sortSort(sortArray[i]);
    }

    System.out.println("\n" + "Array column in descending order");
    displayArray();

}

// Sort rows into ascending order
public static void bubbleSort(int[] numArray) {
    int n = numArray.length;
    int temp = 0;

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

//Sort cols into descending order
public static void sortSort(int[] colArray) {
    int n = colArray.length;
    int temp = 0;

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

//  Print out arrays
private static void displayArray() {
    int i, j = 0;

    System.out.println("-------------------------------------");
    System.out.println(" ");

    for (i = 0; i < sortArray.length; i++) {
        for (j = 0; j < sortArray[i].length; j++) {
            System.out.print(sortArray[i][j] + "\t" + "\t");
        }
        System.out.println();
    }
}

Answer 1

Я переписал ваш sortSort метод сортировки столбцов. Хотя это должно быть не решение, а скорее направить вас в правильном направлении.

Вот как я представляю 2D-массив:

 _ _ _ _ _
|_|_|_|_|_|
|_|_|_|_|_|
|_|_|_|_|_| <rows
 ^
 cols

В коде я бы посмотрел на это так: myArray[row][col]

Но точнее, это массив массивов, так что на самом деле это выглядит примерно так:

 ______________ ______________ ______________
|  _ _ _ _ _   |  _ _ _ _ _   |  _ _ _ _ _   |
| |_|_|_|_|_|  | |_|_|_|_|_|  | |_|_|_|_|_|  |
|______________|______________|______________|
      ^              ^              ^
     row 0          row 1          row 2     

Каждая строка содержит массив столбцов. И в этом проблема - вы не можете сравнить массив строки 0 с массивом строки 1 и сказать, какой массив «больше» ... если вы не отсортируете его по размеру.

В вашей программе вы назвали метод сортировки столбцов следующим образом:

//Print out sorted columns of array
for (int i = 0; i < sortArray.length; i++) {
    sortSort(sortArray[i]);
}

Индекс i перебирает строки и вызывает sortSort. Таким образом, для i=0 он берет первую строку и передает содержащий массив столбцов в sortSort. Таким образом, ваш метод может сортировать только столбцы одной строки.

sortSort(sortArray[i]);  // sortArray[i] represents all columns of row i

Чтобы он сортировал столбцы, он должен знать весь 2D-массив. Колонны и ряды. Это означает, что вы можете сортировать только весь массив одновременно, но не отдельные столбцы.

Давайте посмотрим на это в моем примере:

public static void sortSort(int[][] colArray) {  // we pass the whole 2D-array int[rows][cols]
    int n = colArray.length;    
    int temp = 0;

    // since every row contains a whole array, you cannot really sort the row itself.
    // But you can sort it by its columns value (confusing, I know - sorry)
    // we take the first row as reference (colArray[0])
    // and iterate over every column (from 0 to colArray[0].length)
    // that's a problem, but we get to that later
    for (int col = 0; col < colArray[0].length; col ++) {
        // your sorting loops are working, so we don't change them
        for (int i = 0; i < n; i++) {
            for (int j = 1; j < (n - i); j++) {
                // and here is the magic we compare row j with row j-1 of the current column (col)
                if (colArray[j - 1][col] < colArray[j][col]) {
                    temp = colArray[j - 1][col];
                    colArray[j - 1][col] = colArray[j][col];
                    colArray[j][col] = temp;
                }
            }
        }
    }
}

Вы можете проверить этот код и убедиться, что он работает. Однако это может работать только при определенных обстоятельствах!

Проблема, о которой я упоминал ранее, заключается в том, что в каждой строке нужно ровно столько же столбцов, сколько в первой:

This wouldn't work:
 _ _ _ _ 
|_|_|_|_|       <-- row 1 has 4 columns
|_|_|_|_ _ _    <-- row 2 only 3
|_|_|_|_|_|_|   <-- row 3 has 6 columns

Если вам не нужно выполнять эту работу для переменного числа столбцов - оставьте это так. Если у вас всегда есть хорошая таблица из n строк с каждыми m столбцами, вышеописанный метод делает свое дело.

Answer 2

Просто замените

if (colArray[j - 1] < colArray[j]) {
...
}

с:

if (colArray[j - 1] > colArray[j]) {
...
}

> вместо <

Answer 3

Прежде всего, ваш массив не является 2D :), просто потому, что каждый элемент массива имеет номер, который должен называться как Arr [0], а его значение, например, 5, это не означает его 2D.

но для сортировки массива по убыванию вы можете использовать код ниже:

            int n = intArray.length;
            int temp = 0;

            for(int i=0; i < n; i++){
                    for(int j=1; j < (n-i); j++){

                            if(intArray[j-1] < intArray[j]){
                                    //swap the elements!
                                    temp = intArray[j-1];
                                    intArray[j-1] = intArray[j];
                                    intArray[j] = temp;
                            }

                    }
            }

Answer 4

int[] colArray = new int[] { 2, 9, 4, 5};
int n = colArray.length;
int temp = 0;


for (int i = 0; i < n; i++) {
  for (int j = 1; j < (n - i); j++) {

      if (colArray[j - 1] > colArray[j]) {
          temp = colArray[j - 1];
          colArray[j - 1] = colArray[j];
          colArray[j] = temp;
      }

  }
 }
 Arrays.stream(colArray).forEach(data -> System.out.println(data));