1. Description
Given a positive integer n, to generate a 1 n ^ 2 contains all the elements, and the elements of a square matrix clockwise helically oriented
Example: Input: 3
Output: [
[1, 2, 3],
[8, 9, 4],
[7, 6, 5]
]
2, algorithm
Solution a: Violence O (n ^ 2)
Ideas: circle around printing from outside to inside, each row or column to print when leaving a note
func generateMatrix2(_ n: Int) -> [[Int]] {
//构建矩阵
var matrix : [[Int]] = [[Int]].init(repeating: [Int].init(repeating: 0, count: n), count: n)
//每一圈左边的起始位置和右边的结束位置，由于是正方形座椅列相同
var left = 0, right = n-1
//填充的数字
var insertNum = 1
while left <= right {
//最中间的一个
if left == right {
matrix[left][right] = insertNum
insertNum += 1
}
//最上面一行，除去最后一个
for i in left..<right {
matrix[left][i] = insertNum
insertNum += 1
}
//最右边一列，除去最后一个
for i in left..<right{
matrix[i][right] = insertNum
insertNum += 1
}
//最下面一行，除去最后一个（逆序）
var i = right
while i > left{
matrix[right][i] = insertNum
insertNum += 1
i -= 1
}
//最左边一行，除去最后一个（逆序）
i = right
while i > left {
matrix[i][left] = insertNum
insertNum += 1
i -= 1
}
left += 1
right -= 1
}
return matrix
}
Solution two: determining boundary conditions
Thinking: Boundary conditions for the above four directions to do the judgment, constructing a matrix
func generateMatrix(_ n: Int) -> [[Int]] {
//构建矩阵
var matrix : [[Int]] = [[Int]].init(repeating: [Int].init(repeating: 0, count: n), count: n)
var insertNum = 1
var i = 0
while i<(n+1)/2 {
var j = i
while j < n-i {
//四周终止位置
let l = i, u=i, r=n-1-i, d=n-1-i
//上
var k = i
while k <= r{
matrix[u][k] = insertNum
insertNum += 1
k += 1
}
//右
k = i+1
while k <= d{
matrix[k][r] = insertNum
insertNum += 1
k += 1
}
//下
k = r-1
while k >= l{
matrix[d][k] = insertNum
insertNum += 1
k -= 1
}
//左
k = d-1
while k > u{
matrix[k][l] = insertNum
insertNum += 1
k -= 1
}
i += 1
}
i += 1
}
return matrix
}
Solution three: simulation
Ideas: the whole idea of constructing a matrix using, filled matrix
The filling process is divided into four cases:
Filling line from left to right
From top to bottom filling a
Case filling line from right to left, note that only one row
From bottom to top a filling, where only one of the noted
Time complexity: O (n ^ 2)
func generateMatrix(_ n: Int) -> [[Int]] {
//构建矩阵
var matrix : [[Int]] = [[Int]].init(repeating: [Int].init(repeating: 0, count: n), count: n)
//计算结果值
var resultNum = n*n
//填充矩阵
var rowBegin = 0
var rowEnd = n-1
var columnBegin = 0
var columnEnd = n-1
var insertNum = 1
while insertNum <= resultNum {
//填充矩阵的上边，从左到右填充一行
//每次h循环行不变，列+1，并且循环结束后行+1
var columnTemp = columnBegin
while columnTemp <= columnEnd {
matrix[rowBegin][columnTemp] = insertNum
insertNum += 1
columnTemp += 1
}
rowBegin += 1
//填充矩阵的右边，从上到下填充一列
//每次循环列不变，行+1，并且循环结束后列-1
var rowTemp = rowBegin
while rowTemp <= rowEnd{
matrix[rowTemp][columnEnd] = insertNum
insertNum += 1
rowTemp += 1
}
columnEnd -= 1
//填充矩阵的下边，从右到左填充一行（注意只有一行的情况）
//每次循环不变，列-1，并且循环结束后行+1
columnTemp = columnEnd
while columnTemp >= columnBegin && rowEnd >= rowBegin{
matrix[rowEnd][columnTemp] = insertNum
insertNum += 1
columnTemp -= 1
}
rowEnd -= 1
//填充矩阵的左边，从下到上填充一列（注意只有一列的情况）
//每次循环不变，行+1，并且循环结束后列+1
rowTemp = rowEnd
while rowTemp >= rowBegin && columnEnd >= columnBegin {
matrix[rowTemp][columnBegin] = insertNum
insertNum += 1
rowTemp -= 1
}
columnBegin += 1
}
return matrix
}