Java 气泡排序二维数组

我需要建立一个代码，气泡排序二维数组。这里的技巧是，我不能使用一维数组辅助对象，也不能将项目移动到另一个数组

排序需要在2D数组上进行

现在我构建了我的函数。但有些地方出了问题。这是我的输出

1      1      2      6     12     32
 49     44     54     55    100    344

就要完成了，我想不出该怎么做

 public static int [] [] sortMatrix(int[][]matrix){
    for(int x = matrix.length  ; x >0  ; x-- ){
        for(int i = matrix[0].length  ; i > 0 ; i-- ){
            for(int j = 0 ; j < x  ; j++){
                for(int t = 0 ;t < i    ;  t++){
                    if(t < matrix[0].length - 1 && matrix[j][t] > matrix[j][t+1] ){
                        swap(matrix , j , t, t+1);
                    }
                    else if(t == matrix[0].length - 1 && j != matrix.length -1&& matrix[j][t] > matrix[j+1][0] ){
                        swap1(matrix ,j , t , j + 1);
                    }                       
                }
            }               
        }           
    }

publicstaticint[]]sortMatrix（int[]]matrix）{
对于（int x=matrix.length；x>0；x--）{
对于（int i=矩阵[0]。长度；i>0；i--）{
对于（int j=0；jmatrix[j][t+1]）{
交换（矩阵，j，t，t+1）；
}
如果（t==矩阵[0].length-1&&j！=matrix.length-1&&matrix[j][t]>矩阵[j+1][0]）{
swap1（矩阵，j，t，j+1）；
}                       
}
}               
}           
}

下面是对2D数组进行排序的代码，诀窍是您必须将2D数组视为一维数组，然后为索引导出适当的行、偏移对

import java.util.Arrays;    

public class Bubble2DSort {
    public static void main(String[] args) {
        System.out.println("Started");

        int[][] matrix = {{49,44,54,55,100,344}, {1,1,2,6,12,32}};

        sortMatrix(matrix);

        System.out.println("Printing output ");

        for(int[] rowArr : matrix) {
            System.out.println(Arrays.toString(rowArr));
        }
    }

    private static void sortMatrix(int[][] matrix) {
        int row = matrix.length;
        int col = matrix[0].length;
        int totalCount = row * col;

        System.out.println("totalCount : " +totalCount);

        boolean noSwaps = false;
        for(int i = 0; !noSwaps; i++) {
            noSwaps = true;

            for(int j = 1; j < totalCount - i; j++) {
                int currentRow = (j-1) / col;
                int currentOffset = (j-1) % col;
                int nextRow = j / col;
                int nextOffset = j % col;

                if( matrix[currentRow][currentOffset] > matrix[nextRow][nextOffset]) {
                    //swapping
                    int temp = matrix[nextRow][nextOffset];
                    matrix[nextRow][nextOffset] = matrix[currentRow][currentOffset];
                    matrix[currentRow][currentOffset] = temp;

                    noSwaps = false;
                }
            }
        }
    }
}

试一试

publicstaticint[]]sortMatrix（int[]]matrix）{
//对于矩阵行循环：-
对于（int x=0；x矩阵[x][t+1]）{
//交换操作：-
int temp=矩阵[x][t]；
矩阵[x][t]=矩阵[x][t+1]；
矩阵[x][t+1]=温度；
}
}
}
}                         
收益矩阵；
}

而不是

 public static int [] [] sortMatrix(int[][]matrix){
    for(int x = matrix.length  ; x >0  ; x-- ){
        for(int i = matrix[0].length  ; i > 0 ; i-- ){
            for(int j = 0 ; j < x  ; j++){
                for(int t = 0 ;t < i    ;  t++){
                    if(t < matrix[0].length - 1 && matrix[j][t] > matrix[j][t+1] ){
                        swap(matrix , j , t, t+1);
                    }
                    else if(t == matrix[0].length - 1 && j != matrix.length -1&& matrix[j][t] > matrix[j+1][0] ){
                        swap1(matrix ,j , t , j + 1);
                    }                       
                }
            }               
        }           
    }

publicstaticint[]]sortMatrix（int[]]matrix）{
对于（int x=matrix.length；x>0；x--）{
对于（int i=矩阵[0]。长度；i>0；i--）{
对于（int j=0；jmatrix[j][t+1]）{
交换（矩阵，j，t，t+1）；
}
如果（t==矩阵[0].length-1&&j！=matrix.length-1&&matrix[j][t]>矩阵[j+1][0]）{
swap1（矩阵，j，t，j+1）；
}                       
}
}               
}           
}

一个输入-期望-输出对会很有帮助。

swap

和

swap1

函数不一样？不一样，因为一个交换在行中，另一个在列之间[][]矩阵={{49,54,32,1,2,6}，{1,55,44100344,12}；

 public static int [] [] sortMatrix(int[][]matrix){
    // for loop of matrix rows: -
    for(int x = 0  ; x < matrix.length; x++){
        // for loop of matrix columens: -
        for(int i =0; i < matrix[x].length; i++){
            // for loop of comparison and swapping
            for(int t = 0; t < matrix[x].length - i - 1; t++){
                 if(matrix[x][t] > matrix[x][t+1]){
                      // Swapping operation: -
                      int temp = matrix[x][t];
                      matrix[x][t] = matrix[x][t+1];
                      matrix[x][t+1] = temp;
                 }
            }
        }
    }                         
    return matrix;
}

 public static int [] [] sortMatrix(int[][]matrix){
    for(int x = matrix.length  ; x >0  ; x-- ){
        for(int i = matrix[0].length  ; i > 0 ; i-- ){
            for(int j = 0 ; j < x  ; j++){
                for(int t = 0 ;t < i    ;  t++){
                    if(t < matrix[0].length - 1 && matrix[j][t] > matrix[j][t+1] ){
                        swap(matrix , j , t, t+1);
                    }
                    else if(t == matrix[0].length - 1 && j != matrix.length -1&& matrix[j][t] > matrix[j+1][0] ){
                        swap1(matrix ,j , t , j + 1);
                    }                       
                }
            }               
        }           
    }