InsertionSort с использованием многомерного массива

Question

В моем коде я получаю в первой строке значения n и d. N будет числом значений, которые я хочу записать, и d количеством чисел в каждой позиции n. Итак, в следующих n значениях i знакомит значения d. Цель этого упражнения - использовать сортировку вставки, но если первая координата равна ей, она сравнивает вторую, и если это повторится, то сравнивается третий и т. Д. Пример: Вход:

5 3 
1 1 1 
1 0 1 
1 1 0 
0 1 1 
0 1 0 

Выход:

0 1 0 
0 1 1 
1 0 1 
1 1 0 
1 1 1 

Это мой код:

public static void main(String[] args) { 
    int n,d,aux; 
    Scanner sc = new Scanner(System.in); 

    n = sc.nextInt(); 
    d = sc.nextInt(); 
    int tab [][] = new int[n][d]; 
    for(int i=0;i<n;i++){ 
     for(int j=0;j<d;j++){ 
      aux = sc.nextInt(); 
      tab[i][j] = aux; 
     } 
    } 
    insertionSort(tab,d); 
    System.out.println("---"); 
    for(int u=0;u<tab.length;u++){ 
     for(int y=0;y<d;y++){ 
      System.out.print(tab[u][y]+" "); 
     } 
     System.out.println(); 
    } 
} 
public static void insertionSort(int tab[][],int d){ 
    int i,j; 
    int pos = 0; 
    int tmp [][] = new int[1][d]; 
    for(i = 1;i < tab.length;i++) 
    { 
     for(int k=0;k<d;k++) 
      tmp[0][k] = tab[i][k]; 

     for(j = i; j>0 && tmp[0][0] <= tab[j-1][0];j--) 
     { 
      while(tmp[0][pos] == tab[j-1][pos] && pos+1<d){ 
       pos++; 
       if(tmp[0][pos] < tab[j-1][pos]){ 
        pos=0; 
        break; 
       } 
      } 
      if(pos==0){ 
       for(int k=0;k<d;k++) 
        tab[j][k] = tab[j-1][k]; 
      } 
     } 
     for(int k=0;k<d;k++) 
      tab[j][k] = tmp[0][k]; 
     pos = 0; 
    } 
} 

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

0 1 0 
0 1 1 
1 1 0 
1 1 1 
1 1 1 

Answer 1

I нашел решение для лет у с рекурсией, с кодом ниже вы можете отсортировать многомерный двоичный массив, в двоичном отсортированноге формата (я постоянный массив здесь, вы можете добавить сканер, чтобы получить входы от пульта):

public static void main(String[] args) 
    { 
    int n, d; 

    int tab[][] = new int[][] { { 1, 1, 1, 1 }, { 1, 0, 1, 1 }, { 1, 1, 0, 0 }, { 0, 0, 0, 1 }, 
     { 0, 1, 0, 1 }, { 0, 0, 0, 1 } }; 
    n = 6; 
    d = 4; 
    System.out.println("---"); 
    for (int u = 0; u < tab.length; u++) 
    { 
     for (int y = 0; y < d; y++) 
     { 
     System.out.print(tab[u][y] + " "); 
     } 
     System.out.println(); 
    } 

    insertionSort(tab, n); 

    System.out.println("---"); 
    for (int u = 0; u < tab.length; u++) 
    { 
     for (int y = 0; y < d; y++) 
     { 
     System.out.print(tab[u][y] + " "); 
     } 
     System.out.println(); 
    } 
    } 

    public static void insertionSort(int tab[][], int n) 
    { 
    doSort(tab, 0, n, 0); 
    } 

    /** 
    * Recurring Method for Insertion Sort in MulitDimentional array. 
    * 
    * @param tab mulitidiamentional array. 
    * @param rowsStart the rows start index 
    * @param rowEnd the row end index 
    * @param column the current column 
    */ 
    public static void doSort(int tab[][], int rowsStart, int rowEnd, int column) 
    { 
    int totalColumn = tab[0].length; 
    for (int j = rowsStart; j < rowEnd; j++) 
    { 
     for (int k = j + 1; k < rowEnd; k++) 
     { 
     if (tab[j][column] > tab[k][column]) 
     { 
      for (int l = column; l < totalColumn; l++) 
      { 
      int t = tab[j][l]; 
      tab[j][l] = tab[k][l]; 
      tab[k][l] = t; 
      } 
     } 
     } 
    } 

    int value = tab[rowsStart][column]; 
    if (rowEnd - rowsStart > 2) 
    { 
     for (int i = rowsStart; i < rowEnd; i++) 
     { 
     if (value != tab[i][column]) 
     { 
      doSort(tab, rowsStart, i, column + 1); 
      value = tab[i][column]; 
      rowsStart = i; 
     } 
     } 
    } 
    if (column < totalColumn - 1) 
    { 
     doSort(tab, rowsStart, rowEnd, column + 1); 
    } 
    }