安全オファー証明するために、[19]：時計回りマトリックス印刷

タイトル説明

1,234,567,891,011,121,314 15が順次16プリントアウト：次の4×4行列を入力した場合、例えば、各番号に順次印刷する時計回りの順に外側から内側に向​​かって順に、行列を入力1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10デジタル。

問題の解決：サイクルを回します

1  公共 静的のArrayList <整数> printMatrix（INT [] []行列）{
 2              のArrayList <整数> =結果新しい新規のArrayListを<整数> （）;
 3              IF（matrix.length == 0 ）{
 4。                 リターン結果、
 5              }
 。6              // 行列の初期化の行と列の数
7。             int型の行= matrix.length、カラム=行列[0 ] .LENGTH;
 8              IF（列== 0 ）{
 9                  // 行列の行数は、行列の列の数、0でない場合それはまだ、行列の空の要素を意味する、空のリスト0である
10                  リターン結果;
 11              }
12は、             / * 
13れる              ループは、より小さな値は、行と列によって決定される、小さい値が-1の場合を考慮するために奇数である、層の層を介し*
 14               各ループの先頭が原因になっているので、*は2で除算され使用済ライン2ながら右へ及び右から左への左下には、これだけ半分取る
 15               + 1偶奇の前層を補償するために、少なくとも1つの層を* 0.5 -1条件が原因
 16               * / 
17              INTを =レイヤー（Math.min（行、列）-1）/ 2 + 1 ;
 18である             ため（INT I = 0、I <レイヤー; I ++ ）{
 19                  / * 
20                   *左上からから出発して、右上の対角要素に左上の左下からそれぞれにので、現在の行、前の要素の複数ので、開始Jを使用します= I。
21                   *指数を以下の後ろに費やされる右現在の行の右下の要素に前のラウンドのように現在のサイクルを、減算マトリックス層の列の数よりも横断
 される22                   * * / 
23である                 ため（INTIは、Jが=、J <カラム-I; J ++ ）{
 24                      result.add（行列[I] [J]）;
 25                  }
 26は、                 / * 
27                   このラウンドは、上側左右されるので、右下に右上から*マルチ現在の列要素上に費やしたので、開始K = I + 1。
28                   *インデックスをトラバース左下素子の右下から最初のラウンドは、現在の列以下費やされるため、少ない電流サイクルを減算マトリックス層、の行数を超えています。
29                   *最大インデックス行列の列は、列1（0から始まる）、充填結果リストの列列番号マイナス最大サイクル率層の構成要素である
 30                   前のラウンドは、現在の右下に右上から費やされるよう*列列要素の後に
 31である                  * * / 
32                  のための（int型 K = I + 1; K <行-I; K ++ ）{
 33れる                      （行列[K] [カラム-1- result.add I]）;
 34のIS                 }
 35                  / * 
36                   左下の右下から*前と合わせ、現在の背後に多列の右の要素の右下にこれので、最大値インデックス行列の列は、列1（0から始まる）であります右車輪
 37                   のI番目の要素の後ろに右下に費やさ*、開始Jよう=カラム-1-I-
 1。38                   前のラウンドは、下部左上欄要素左からI-1の前に費やされるので、より大きい最後のサイクルの間に現在の列の左または層の数に等しい下に右下から*指数、Jので> = I。
39                   *考慮行の数が、層の数を減算することによって、行1行（0から行番号の開始）現在のサイクルの最大屈折率は、層の現在のサイクル数と等しくないように、より少ない行列の列の数（例えば、行6 3）よりなる場合取っ
 40                   *それ以外の場合は、左から右へ、上から最後のラウンドの後、次は左下の要素に右下から同じラウンドを繰り返す必要があります。
41                   前者は下右下左からラウンド素子列電流ラインの下に費やされるので、層の最大サイクル数を減算することにより、行インデックスの*フィル結果リスト要素の行番号
 42をれる                  * * / 
43である                 ため（INT J =カラム・I-2;（J> = I）&&（=行-I-I 1。！）; J、）{
44れる                      （行列[1-行優先result.add I] [J]）;
 45                  }
 46である                 / * 
47                   下部左上に左から*がAであるため、最大インデックス行列の行は、行1（0から始まる）であります下部から前のラウンドと合わせ現在の列、後ろ多要素の左側に右下から
 48                   *左上に左下費やさi番目の要素以下、開始Kよう=行1-I-
 1。49                   下側の最後のサイクルの間、現在の行の左上に左から*指数は、層の数、および行jよりも大きい>異なるI =
 50                   *ここで、等号が最終的にプロセスの上部右に左にこれを繰り返す必要があります場合最初の要素なので、K> I。
51                   *列column-1の最大屈折率マイナス現在のサイクルが層の層の現在のサイクル数と等しくないように、一列に（例えば、6行3列）のマトリックスの列の数よりも少ない服用
 52                   *、又は最終的に右右下に、次のラウンドは、左上に左下から同じ要素を繰り返す必要があります。
53                   *の現在の列インデックスの同じ要素のフィル結果リストの列番号左上Iであり、要素の開始の右上に
 54であります                  ** / 
55                  のための（int型 ;（K> I）&&（列1-I = I）！k-- K =行-2- I {）
 56                      result.add（行列[K] [I]）。
57                  }
 58              }
 59              リターン結果。
60          }

問題の解決II：旋回を印刷

1  プライベート 静的 ArrayListに<整数>リスト= 新しい ArrayListを<> （）;
2      公共のArrayList <整数> printMatrix01（INT [] []行列）{
 3          int型の行= matrix.length。
4          int型の列=行列[0 ] .LENGTH。
5          int型の開始= 0 ;
6          しばらく（行>開始* 2 &&列>開始* 2 ）{
 7              printMatrixInCircle（行列、行は、列は、開始）。
8              ++開始。
9          }
 10          リターンリスト。
11      }
 12である     パブリック 静的 ボイド printMatrixInCircle（INT [] []マトリックス、int型の列、int型の列、INT スタート）{
 13れる         // 右印刷ライン左
14          用（INT Iがスタート=; I <カラム-スタート; I ++ ） {
 15              List.add（行列[スタート] [I]）;
 16          }
 17。         // 下へ、印刷
18である         ため（INT J =スタート+ 1、J <行-スタート; J ++ ）{
 19。              List.add（行列[J] [カラム-スタート- 1。]）。
20          }
 21          // 印刷ラインに右から左に
22である         ため（INT M =列-スタート- 2、M> =スタート&&行-スタート- 1>のスタート; M-- ）{
 23が              List.add（行列[行-スタート- 1 ] [M]）;
 24          }
 25          // 下部からの印刷に
26である         ため（INT = N-行-スタート- 2; N->列=開始+ 1 && -スタート- 1>の開始; N-- ）{
 27              List.add（マトリックス[N-] [スタート]）;
 28          }
 29      }

問題の解決策III：長方形フリップ

1  公共 静的のArrayList <整数> printMatrix02（INT [] []行列）{
 2          // 結果のコンテナとして
3          のArrayList <整数> =一覧新しい新規のArrayList <> （）;
 4          // 配列GET事故の行数
5          INTの行= matrix.length;
 6          しばらく（行！= 0 ）{
 7。             // 容器を追加する配列の最初の行
8。             ため（INT I = 0; I <行列[0] .LENGTH; I ++ ）{
 9                  List.add（行列[0 ] [I]）;
 10              }
 11。             //行の数は、1に等しいときに続行する必要がなく、上部ストッパにその上に印刷が完了した後
12は、             IF（行== 1 ）{
 13は                 BREAK ;
 14              }
 15              // 最初の行の上に削除アレイトラバーサル、およびこのアレイ回転戻る
16を              マトリックス= 元に戻す（マトリックス）;
 17              // 更新された行の数
18は、              行= matrix.length;
 19          }
 20である         // リターン
21は、         リターン・リスト、
 22である     }
 23が     プライベート 静的 INT [] []元に戻す（INT [ ] []行列）{
 24          // 行列の行と列の数を取得する
25         int型の列= matrix.length;
 26件         のint COLS =行列[0 ] .LENGTH;
 27         // 私達は元の配列の最初の行が削除横断しているので、その後、新しい配列にこの新しい初期化時にその最初の一見を回転させますアレイ
28          のint [] [] = newMatrix 新しい新しい INT [COLS] [-rows 1。];
 29          // この新しい割り当てアレイ
30          のための（INT J = -cols 1; J> = 0; J、）{
 31、IS              用（INT I = 1; I <行; I ++ ）{
 32                  newMatrix [-J-colsの1] [I-1] = 行列[I]、[J];
 33である             }
 34である         }
 35          //新しい配列を返し
36          リターンnewMatrixは、
 37      }

テスト：

1  公共 静的 ボイドメイン（文字列[]引数）{
 2          のint [] []行列= {{1、2、3、4}、{5、6、7、8}、{9、10、11、12} 、{13、14、15、16 }}。
3          のArrayList <整数>リスト= printMatrix（マトリックス）
4          のための（整数整数：リスト）{
 5              System.out.print（整数+」 " ）。
6          }
 7      }
 8输出：1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10