Chapter 1 | Arrays and Strings--旋转N*N矩阵的图像和处理M*N矩阵，若某位置为0则所在行和列均置0

1.6    Given an image represented by an NxN matrix, where each pixel in the image is 4 bytes, write a method to rotate the image by 90 degrees.Can you do this in place?

译文：给定一张表示成N*N矩阵的图像，图像中每个像素是4个字节。写一个函数原地旋转图像90°，即不开辟额外的数据空间。

图像旋转90°，顺时针逆时针都无所谓

假定原图矩阵表示为（这里举例4*4矩阵是为了表述更加直观，只要是N*N矩阵，那么原理都是一样的）

 1  2   3    4
 5  6   7    8
 9  10  11  12
13  14  15  16

顺时针旋转90°之后为

13   9   5  1
14  10   6  2
15  11   7  3
16  12   8  4

看到这个题目的第一感觉就是一个个的交换来实现旋转，但是我们一个个的处理也要有点技巧。图像旋转，说是矩阵旋转更贴切，我们可认为先是最外层旋转，然后里面那层旋转，这样一层层的旋转，直到最里层，那么矩阵的旋转即完成。一层的旋转是很有规律的，先交换顶角，然后逐步推移就可以了。

有了上面的分析写程序就好办了，我们主要考虑的是矩阵旋转的层数以及每一层每一轮要交换的次数。每一层每一轮交换就是说每一层我们需要交换几轮(矩阵的特点：每轮交换四个)才能实现这一层的旋转。很容易得知矩阵旋转的层数为N/2，每一层每一轮交换的次数就由该层矩阵的阶次来决定了。代码如下                                                

void rotate(int matrix[][4], int n)
{
	for (int i = 0; i < n / 2; ++i)   //旋转层数
	{
		int first = i;
		int last = n - i - 1;
		for (int j = first; j < last; ++j)  //每一层交换次数
		{
			int offset = j - first;         
			int top = matrix[first][j];     //保存左上顶点
			//左下顶点-->左上顶点
			matrix[first][j] = matrix[last - offset][first];
			//右下顶点-->左下顶点
			matrix[last - offset][first] = matrix[last][last - offset];
			//右上顶点-->右下顶点
			matrix[last][last - offset] = matrix[j][last];
			//左上顶点-->右上顶点
			matrix[j][last] = top;
		}
	}
}

这里还另外介绍一种方法，就是探讨矩阵本身旋转的结构。

旋转90°，我们可以利用主对角线进行数据对称交换，然后依次交换第i列和第n-i-1列

 1  2   3   4                    1  5  9 13                 13  9   5  1
 5  6   7   8         ----->     2  6 10 14         ----->  14  10  6  2
 9  10  11  12                   3  7 11 15                 15  11  7  3
13  14  15  16                   4  8 12 16                 16  12  8  4

代码如下

void swap(int &a, int &b)
{
    if (a != b)
    {
        a ^= b;
        b ^= a;
        a ^= b;
    }
}

void rotate(int image[][4])
{
    for (int i = 0; i < 4; ++i)           //rows
    {
        for (int j = i + 1; j < 4; ++j)   //cols
            swap(image[i][j], image[j][i]);
    }

    for (int i = 0; i < 4; ++i)           
    {
        for (int j = 0; j < 2; ++j)       
            swap(image[i][j], image[i][4 - i - 1]);
    }
}

上面这个就很好的体现了先分析问题研究方法，然后再将方法实现，而不是一味的拿到东西就直接编码。
另外，这个函数以及上面那个值得注意的是，这里二维数组是作为形参传递，必须指定第二维。你也可以这样申明

void rotate(int **matrix, int n)

然后再调用的时候这样写

rotate((int**)matrix, 4);

不过在转变后的函数中，matrix[first][j] 这样是不对的，因为编译器不能正确为它寻址，所以我们要模仿编译器修改函数中二维数组寻址方式，将其手动转变为

*((int*)(matrix+cols*i)+j);  //cols表示矩阵的行数

关于指针与数组（多维）之间的渊源与区分，这里就不讨论了，多维数组实际就是按一维数组存放的，为方便处理，我们就人为的规划了一下。有时候探讨一下底层的玩意也挺有意思的，反汇编成汇编语言。

1.7   Write an algorithm such that if an element in an M*N matrix is 0,its entire row and column is set to 0.

译文：写一个算法来处理一个M*N矩阵，如果矩阵中某个元素为0，则将该元素所在行和列的元素均置0。

这个属于简单型的。遍历一次矩阵，记录下元素为0的位置(行和列)，第二次遍历矩阵的时候，就将记录下的位置所在的行和列元素置0。为此我们需要另外开辟两个数组来分别记录下0元素行与列的位置，这个比较简单，就直接贴代码了

void setZeros(int **matrix, int m, int n)
{
	bool *row = new bool[m];
	bool *col = new bool[n];
	memset(row, false, sizeof(row) * m);
	memset(col, false, sizeof(col) * n);

	for (int i = 0; i < m; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			if (0 == *((int*)matrix+n*i+j)/*matrix[i][j]*/)
			{
				row[i] = true;
				col[j] = true;
			}
		}
	}

	for (int i = 0; i < m; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			if (row[i] || col[j])
				*((int*) matrix + n*i + j) = 0;
		}
	}
}

题目简单，这里要注意的就是二维数组形参传递了