У меня проблема с сортировкой матрицы. [Сортировка слиянием]

Question

Отображение списка столбцов матрицы на экране в порядке убывания максимума в соответствующих столбцах; сортировка данных будет осуществляться с помощью сортировки слиянием. Я пишу максимальные элементы в векторе, затем вектор сортируется, и уже по вектору вы должны отобразить столбцы. И если в матрице 2 одинаковых числа, он должен отображать правильный столбец, он должен работать с координатами, но я не смог.

2  6  1 
10  5  11 
4  8  9 

Окончательный результат

1  2  6 
11  10  5 
9  4  8

static void maxVec(int[][] myArray, int n, int m) {
        int[] elMax=new int[m];
        for (int i=0; i<m; i++) {
            int max=0;
            if(n>m) {
                int count=(n-m);
                for (int j=0; j<myArray[i].length+count; j++) {
                    if(myArray[j][i]>max) {
                        max=myArray[j][i];
                    }
                }
            }
            if(n==m) {
                for (int j=0; j<myArray[i].length; j++) {
                    if(myArray[j][i]>max) {
                        max=myArray[j][i];
                    }
                }
            }
            if(n<m) {
                int count=(m-n);
                for (int j=0; j<m-count; j++) {
                    if(myArray[j][i]>max) {
                        max=myArray[j][i];
                    }
                }
            }
            elMax[i]=max;
        }
        mergeSort(elMax, elMax.length);
        for(int i=0;i<elMax.length;i++) {
            System.out.print(elMax[i]+" ");
        }
        System.out.println("\n===================================");
//here i don't know what to do
        for(int k=0;k<elMax.length;k++) {
            for (int i=0; i<myArray.length; i++) {
                for (int j=0; j<myArray[i].length; j++) {
                    if(elMax[k]==myArray[i][j]) {
                            for (int w=0; w<myArray[w].length; w++) {
                                System.out.print(myArray[i][w]+" ");
                            }
                            System.out.println();


                    }
                }
            }
        }
    }
    //merge sort



    public static void merge(
              int[] a, int[] l, int[] r, int left, int right) {

                int i=0, j=0, k=0;
                while(i<left && j<right) {
                    if(l[i]>=r[j]) {
                        a[k++]=l[i++];
                    }
                    else {
                        a[k++]=r[j++];
                    }
                }
                while(i<left) {
                    a[k++]=l[i++];

                }
                while(j<right) {
                    a[k++]=r[j++];
                }
            }

    public static void mergeSort(int[] a, int n) {
        if(n<2) {
            return;
        }
        int mid =n/2;
        int[] l = new int[mid];
        int[] r = new int[n-mid];

        for(int i=0;i<mid;i++) {
            l[i]=a[i];
        }
        for(int i=mid;i<n;i++) {
            r[i-mid]=a[i];
        }
        mergeSort(l, mid);
        mergeSort(r, n-mid);

        merge(a, l, r, mid, n-mid);
    }

Answer 1

надеюсь, что это поможет вам, и лучше использовать это на не очень большой матрице,

class Matrix {

    int[][] matrix = new int[][] {
        { 1,  3,  5, 16,  9},
        { 2,  4, 15,  6,  0},
        {18, 14, 17, 11, 10},
        {14, 15, 12, 16, 13}
    };

    void sortByColumn() {

        class ColMax {
            int col;
            int val;

            ColMax(int c, int v) {
                col = c;
                val = v;
            }

            @Override
            public String toString() {
                return "[" + col + ": " + val + "]";
            }
        }

        int cols = matrix[0].length;
        int rows = matrix.length;
        int[][] target = new int[rows][cols];
        ColMax[] colmaxes = new ColMax[cols];

        for (int i = 0; i < cols; i++) {
            colmaxes[i] = new ColMax(i, matrix[0][i]);
        }

        // find every column's max item  
        for (int i = 0; i < cols; i++) {
            for (int k = 0; k < rows; k++) {
                if (colmaxes[i].val < matrix[k][i]) {
                    colmaxes[i].val = matrix[k][i];
                }
            }
        }

        // sort it descending
        Arrays.sort(colmaxes, (a,b) -> b.val - a.val);

        for (int i = 0; i < cols; i ++) {
            System.out.print(colmaxes[i] + ", ");
        }
        System.out.println();

        // copy sorted cols 
        for (int i = 0; i < rows; i++) {
            for (int k = 0; k < cols; k++) {
                target[i][k] = matrix[i][colmaxes[k].col];
                System.out.print(target[i][k] + ", ");
            }
            System.out.println();
        }   
    }
}