2d Array in gewundenen Reihenfolge

Question

Ich versuche, ein Array in der Reihenfolge der Spirale zu füllen. Bis jetzt kann ich das Array in spiralförmiger Reihenfolge drucken, aber gibt es eine Möglichkeit, das Array so zu ändern, dass ich es in einer spiralförmigen Reihenfolge ausfüllen und dann das Array einfach ausdrucken kann? Ich möchte, dass es in absteigender Reihenfolge wie ein Countdown läuft. Bitte helfen Sie!

public class Spiral { 
    public static void main(int m, int n) { 

    // create m by n array of integers 1 through m*n 
    int[][] values = new int[m][n]; 
    for (int i = 0; i < m; i++) 
     for (int j = 0; j < n; j++) 
      values[i][j] = 1 + (m*n)*i + j; 

    // spiral 
    for (int i = (m*n)-1, j = 0; i > 0; i--, j++) { 
      for (int k = j; k < i; k++) System.out.println(values[j][k]); 
      for (int k = j; k < i; k++) System.out.println(values[k][i]); 
      for (int k = i; k > j; k--) System.out.println(values[i][k]); 
      for (int k = i; k > j; k--) System.out.println(values[k][j]); 
    } 
    } 
} 

Answer 1

Wenn Sie Code herausgefunden haben, das liest zu tun (zum Drucken), kann man dann nur, dass ändern, anstatt zu tun, schreibt die gleiche Logik?

Wenn Sie jede Zelle in der Matrix wollen seine „laufende Nummer“ enthalten, rückwärts gezählt wird, so etwas wie dies funktionieren soll, ist Ihre Zugriffslogik unter der Annahme richtig:

for (int i = (m*n)-1, j = 0, index = m * n; i > 0; i--, j++) { 
     for (int k = j; k < i; k++) values[j][j] = index--; 
     for (int k = j; k < i; k++) values[k][i] = index--; 
     for (int k = i; k > j; k--) values[i][k] = index--; 
     for (int k = i; k > j; k--) values[k][j] = index--; 
} 

Answer 2

nicht die effizienteste, aber es sollte funktionieren: g ist das Array. Ich verwende auch Ausnahmen zur Steuerung der Logik.

public static void spiralFill() 
{ 
    x = (g.length-1)/2; 
    y = (g[0].length-1)/2; 

    try 
    { 
     while(true) 
     { 
      east(); 
      south(); 
      step++; 
      west(); 
      north(); 
      step++;   
     } 
    } 
    catch(ArrayIndexOutOfBoundsException e) 
    { 

    } 
} 

public static void east() 
{ 
for(int i = 0; i < step; i++) 
{ 
     g[x][y] = count; 
     count++; 
    x++; 
    } 
} 
public static void south() 
{ 
    for(int i = 0; i < step; i++) 
    { 
     g[x][y] = count; 
     count++; 
     y--; 
    } 
} 
public static void west() 
{ 
    for(int i = 0; i < step; i++) 
    { 
     g[x][y] = count; 
     count++; 
     x--; 
    } 
} 
public static void north() 
{ 
    for(int i = 0; i < step; i++) 
    { 
     g[x][y] = count; 
     count++; 
     y++; 
    } 
} 

Answer 3

Hier einige der Variationen:

public class SpiralMatrix { 

    private static int[][] createSpiralMatrix(int size) { 
     int[][] matrix = new int[size][size]; 

     int row = 0, col = -1; 
     int value = 1; 

     boolean horizontal = true; 
     boolean increasing = true; 
     boolean finish = false; 

     while(!finish) { 

      finish = true; 
      if (horizontal && increasing) { 
       while(tryAndSet(matrix, row, col + 1, value)) { 
        finish = false; 
        col++; 
        value++; 
       } 
      } else if (horizontal && !increasing) { 
       while(tryAndSet(matrix, row, col - 1, value)) { 
        finish = false; 
        col--; 
        value++; 
       } 
      } else if (!horizontal && increasing) { 
       while(tryAndSet(matrix, row + 1, col, value)) { 
        finish = false; 
        row++; 
        value++; 
       } 
      } else { 
       while(tryAndSet(matrix, row - 1, col, value)) { 
        finish = false; 
        row--; 
        value++; 
       } 
      } 

      if (!horizontal) { 
       increasing = !increasing; 
      } 
      horizontal = !horizontal; 
     } 

     return matrix; 
    } 


    private static boolean tryAndSet(int[][] matrix, int row, int col, int value) { 
     if (row < 0 || col < 0 || row >= matrix.length || col >= matrix[row].length || matrix[row][col] != 0) { 
      return false; 
     } 
     matrix[row][col] = value; 
     return true; 
    } 

    private static void printMatrix(int[][] matrix) { 
     for (int i = 0; i < matrix.length; i++) { 
      for(int j = 0; j < matrix[i].length; j++) { 
       System.out.print("\t" + matrix[i][j]); 
      } 
      System.out.println(); 
     } 
    } 


    public static void main(String[] args) { 
     try { 
      int[][] spiralMatrix = createSpiralMatrix(40); 
      printMatrix(spiralMatrix); 
     } catch (Throwable th) { 
      th.printStackTrace(); 
     } 
    } 

Answer 4

int maxValue = target.length * target[0].length; 

private int[][] generateMatrix(int[][] target, int level, int currentVal) { 
    // always start from lower left corner in each layer 
    int w = level; 
    int h = target.length - level - 1; 

    // fill the bottom line 
    int i = 0; 
    for (i = w; i < target[0].length - level && currentVal <= maxValue; i++) { 
     target[h][i] = currentVal++; 
    } 

    w = target[0].length - level - 1; 

    int j = 0; 
    // fill the right line 
    for (j = h - 1; j >= level && currentVal <= maxValue; j--) { 
     target[j][w] = currentVal++; 
    } 

    h = level; 

    // fill the above line 
    for (i = w - 1; i >= level && currentVal <= maxValue; i--) { 
     target[h][i] = currentVal++; 
    } 
    w = level; 

    // fill the left line 
    for (j = h + 1; j < target.length - level - 1 && currentVal <= maxValue; j++) { 
     target[j][w] = currentVal++; 
    } 

    if (currentVal > maxValue) 
     return target; 
    return generateMatrix(target, ++level, currentVal); 

} 

Answer 5

public ArrayList<Integer> spiralOrder(final List<ArrayList<Integer>> a) { 
    ArrayList<Integer> result = new ArrayList<Integer>(); 
     int m = a.get(0).size(); 
     int n = a.size(); 
     if(m>1 && n>1){ 
     int loopCounter = (n > m) ? m*2 : n *2 -1 ; 
     int opr=1; 
     int i=0,j=0; 
     int opA=m,opB=n,opC=0,opD=1; 
     for(int k=0;k < loopCounter ;k++){ 
       if(opr == 1){ 
       int counter =0; 
       while(counter < opA){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter++; 

        if(j != opA-1){ 
         j++; 
        } 
        else{ 
         break; 
        } 
       } 
       opr =2; 
       continue; 
      } 
      if(opr == 2){ 
       i++; 
       int counter =1; 
       while(counter < opB){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter++; 

        if(i != opB-1){ 
        i++; 
        } 
        else{ 
         break; 
        } 
       } 
       opr =3; 
       continue; 
      } 
      if(opr == 3){ 
       j--; 
       int counter =j; 
       while(counter >= opC){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter --; 
        if(j != opC){ 
        j--; 
        } 
        else{ 
         break; 
        } 
        } 
       opr =4; 
       continue; 
      } 
      if(opr == 4){ 
       i--; 
       int counter = i; 
       while(counter >= opD){ 
        System.out.print(a.get(i).get(j)+ ";"); 
        result.add(a.get(i).get(j)); 
        counter --; 
        if(i != opD){ 
        i--; 
        }else{ 
         break; 
        } 
       } 
       opr =1; 
       j++; 
       opA = opA -1; 
       opB = opB -1; 
       opC= opC +1; 
       opD = opD+1; 
       continue; 
      } 
     } 

    } 

     else if(n ==1){ 
       for(int k=0;k < a.get(0).size();k++){ 
        result.add(a.get(0).get(k)); 
       } 
     } 

     else if(m==1 && n==1){ 
      result.add(a.get(0).get(0)); 
     } 

    // Populate result; 
    return result; 

}