我对矩阵进行排序有问题。 [合并排序]

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();
        }   
    }
}