Q：
之前朋友跟我聊了道算法题，是顺时针输出数组矩阵，如图1所示：
简单写了下算法，语言无所谓，思路都差不多，我用 OC 写了下；如果只是需要代码，可以点Git链接拷下；如果需要思路，可以接着往下看；
A：
首先咱们来合计合计啊，前置条件只给这个矩阵的宽高；这个矩阵可以理解为大学学的二维数组，宽高，对应他的 x y 轴；所以，大概分3步;
1.构建数据源，并且准备好输出用的二维数组；
2.把数据源，按要求填充进二维数组；
3.log这个数组就完事啦~
SO，米娜桑，分析完毕，开启战斗模式：
1. 构建数据源，以及容器二维数组
要求 x*y 的矩阵，那么数据源就是 1 到 x*y ；至于 log 用的二维数组，很多语言里的二维数组，是用数组套数组来实现的，第一反应很可能会觉得类似 array1；但其实，他是 array2 样式的，和第一反应的不太一样；
很好验证，这样来想，矩阵作为二维坐标系，把第一排第一个为坐标原点，也就是x0y0，那么如果你想取第1排第二个元素2，那么x1 y0；但直接转到数组里取 array[1][0]，你会发现取的是第2个子数组的第一个元素，也就是8；
有没有发现，想取2的话，应该是 array[0][1]，和刚才是[1][0]的反过来的；毕竟二维数组中，后一位才表示处于子模块的第几个；但是数组竖着看确实有点别扭，我就是想横着算！咋整呢？
恩，小场面，赋值 array[x][y] 的时候，把 xy 换位置即可，也就是用 array[y][x]，可以理解为把上图坐标系中，x轴 y轴 对换一下。大家可以试下，如果按 array[x][y] 赋值的话，会变成逆时针，很好玩的；
还有一个要注意的就是，构建二维数组时也是要反过来的；比如 3*5 的矩阵，那么，二维数组就是有5个子数组，每个子数组有3个元素；要是直接按 3 5理解，3个子数组，每个子数组5个元素，那后面就数组越界了，蹦沙卡拉卡💥
- (void)logMatrixWithWidth:(NSInteger)width height:(NSInteger)height{
//构造数据源数组，例如 3*3 的矩阵，那么数组就装 1，2，3，4，5，6，7，8，9
NSMutableArray *originArray = [NSMutableArray arrayWithCapacity:width * height];
for (int i = 1; i <= width*height; i++) {
[originArray addObject:@(i)];
}
//构造 log 用的容器二维数组
NSMutableArray *logArr = [NSMutableArray arrayWithCapacity:height];
for (int i = 0; i < height; i++) {
NSMutableArray *arr = [NSMutableArray arrayWithCapacity:width];
for (int j = 0; j < width; j++) {
[arr addObject:@"w"];
}
[logArr addObject:arr];
}
//二维数组填充，并 log
[self logWithTwoDimensionArray:[self arrangeWithWidth:width height:height originArray:originArray logArray:logArr]];
}
2. 接下来，咱们进行数据填充；
四边形，数字螺旋排列，情况还是比较少的，一共 A B C D 4种；OK，那咱们就干脆给他列出来，然后再考虑合并以及优化；
Git 链接里，有优化后和优化前的代码，可以拿优化前的，对照这段一起看；
首先定义 x=0 y=0，以及 j = 1；j 作为当前操作列/行的第几位，拿来取余用，这样也可以把循环控制，和数据源里的数据隔离开，要不然万一给的数据源要求是一群素数，或者一些没关系的数，那就麻烦了；
再定义两个 BOOL，coordinateX = YES 当前是否在 X 轴上，inCrease = YES 当前是否为递增；然后拿数据源里的数据，开始循环赋值 array[y][x] = num；当是最后一个时，break 掉；
在 for 循环里，赋值后，根据是否在 X 轴，和当前是否递增，可判断是 A B C D 中的哪一轮，并分别处理如下：
A 递增: （从原点开始，那也就是 A 情况开始）
j 对宽取余 j % width，若除尽证明该行完成，即本轮 X 轴完成，则 coordinateX 置 NO，表明下次为 Y 轴；y++，x不变，j 重新置为1；因为当前行完成，相当于对 Y 方向上少了1，所以 height--；接下来还是递增，所以 inCrease 不变；
若 j % width 取余不为0，则这行还没完成，那么 x++, j++ 继续；
B 递增：
j 对高取余 j % height，若能除尽证明该列完成，即本轮 Y 轴完成，则 coordinateX 置 YES；因为接下来要往回走，所以 x--，y不变，j 重新置为1；因为当前列完成，相当于 X 方向上少了1，所以 width--；接下来要递减，所以 inCrease 置 NO；
若 j % height 取余不为0，则该列还没完成，那么 y++, j++ 继续；
C 递减：
j % width，若除尽，则本轮 X 轴完成，coordinateX 置 NO；因为接下来要 Y 方向往回走，所以 y--, x不变，j 重置为1；和上面原理相同，本行走完， height--；接下来还是递减，所以 inCrease 不变；
若 j % width 取余不为0，则该行还没完成，那么 x--, j++ 继续；
D 递减：（只要数据源没循环完，那么 D 走完，接着走 A）
j % height，若除尽，则本轮 Y 轴完成，coordinateX 置 YES；因为接下来走 X 增方向，所以 x++, y不变，j 重置为1；和上面同理，本列走完，width--；接下来是递增，所以 inCrease 置 YES；
若 j % height 取余不为0，则该列还没完成，那么 y--, j++ 继续；
写完后，还可以优化上面的逻辑；
其实在 X 轴上的 AC，Y 轴上的 BD ，各自内部的处理基本是一致的；唯一区别就是 ++ 还是 --，以及 Y 轴涉及到一个 inCrease 的改变；
那么，就可以把 AC 合并，BD 合并；合并后的最终代码如下：
// 构造顺时针螺旋的二维数组
- (NSArray *)arrangeWithWidth:(NSInteger)width height:(NSInteger)height originArray:(NSArray *)originArray logArray:(NSMutableArray *)logArr {
NSInteger j = 1;
NSInteger x = 0;
NSInteger y = 0;
BOOL coordinateX = YES;
BOOL inCrease = YES;
for (NSNumber *num in originArray) {
logArr[y][x] = num;
if ([originArray lastObject] == num) { //若已是最后一个，则直接 break
break;
}
if (coordinateX) { //坐标 x
if (j % width == 0) {
coordinateX = NO;
j = 1;
height--;
inCrease ? y++ : y--;
} else {
j++;
inCrease ? x++ : x--;
}
} else { //坐标 y
if (j % height == 0) {
coordinateX = YES;
j = 1;
width--;
inCrease ? x-- : x++;
inCrease = !inCrease;
} else {
j++;
inCrease ? y++ : y--;
}
}
}
return [logArr copy];
}
3. 把二维数组 log 出来；
这个就很简单了，没啥细说的；不过有一点，当数据量大时，比如 5*6 的矩阵，那么最大30，最小1；一位数和两位数占位肯定不一样，就很容易对不齐；
如果所有数字占位一样，那就很整齐啦~ 我懒省事，直接指定了占2位；当然最严谨的方法还是拿到最大数，看是几位，然后设置所有的都按这么长来占位；
// 输出二维数组
- (void)logWithTwoDimensionArray:(NSArray *)twoDimensionArray {
for (NSArray *arr in twoDimensionArray) {
NSMutableString *str = [NSMutableString string];
for (NSNumber *num in arr) {
[str appendFormat:@"%2d ",num.integerValue];
}
NSLog(@"%@",str);
}
}
