剑指Offer(十九)——顺时针打印矩阵

题目描述

输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字。

例如,如果输入如下4 X 4矩阵:

1   2    3     4

5   6    7     8

9   10  11   12

13 14  15    16

则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

 

思想:

一圈一圈的打印,这道题难点在于何时中止打印。

图为在矩阵中某一圈,length为矩阵长度,width为矩阵宽度,坐标值为数组下标。

对于我们这道题来说,只要有内圈可以进入下一圈就是以第一圈(0,0)    第二圈 (1,1) ……的规律做每一圈的起点

现在考虑以下标(i,i)为起点的一圈,其图像为length为矩阵长度,width为矩阵宽度

打印过程是四个for循环以此为上-》右-》下-》左顺时针遍历

按照图我们开始遍历第i圈

//注意四个角的元素不能重复
//上 行i 列i  length-i-1
for (int j=i; j <= length-i-1; j++) {
	result.push_back(matrix[i][j]);
}
//右 列 length-i-1 行i+1
for (int j= i+1; j <= width - i - 1; j++) {
	result.push_back(matrix[j][length-i-1]);
}
//下 行width-i-1  列length-2-1  到i
for (int j = length-i-2; j >= i; j--) {
    result.push_back(matrix[width-i-1][j]);
}
//左 列i  行 width-i-2  到 i+1
for (int j = width-i-2; j > i; j--) {
	result.push_back(matrix[j][i]);
}

  

  

现在一圈完了,下一圈会不会有什么突发状况?

思考:假设下一圈就结束循环了,那么可能遇到什么情况,下一圈不再是一个完整矩形(指的是长宽都大于1的矩阵)而是有四种可能。我们之所以分析是要看这几种情况对我们四个for循环是否都适用

1.没有元素

2.只有一个元素

3.只有一行元素

4.只有一列元素

好的,现在我们知道了所有可能的形状。那进入到这几种情况我们就要考虑了。

1.本圈矩形的长宽只要任意一个为0就结束循环,没有元素了 条件 宽0长0   length-2i<=0或width-2i<=0  

此时直接跳出循环即可,四个for循环都不满足

2.只有一个元素和只有一行元素  就是我们只需要进行 顺势针打印的上面部分,此时条件是 宽1长若干  (width-2i==1且length-2i大于1)化简此时 width=2i-i

//打印一行没有问题,按道理来说是不是之后的打印都不应该做

观察下

右面打印的判断条件   int j= i+1; j <= width - i - 1; j++   因为宽度为1  初始    width为2i+1   代入for循环判断不满足   j=i+1<  i条件

下面打印的判断条件   int j = length-i-2; j >= i; j--   假设length无穷大,那可进入for循环从左到右打印

左面打印的判断条件类似右面,因宽度为1本身就可限制

总结:因长度大于1,宽度等于1出现重复打印情况如下:

所以我们在   顺时针上面对应的for结束,右侧下面左侧的for可以避免。但是我们下侧for循环就需要有判断条件,为   if(宽度为1则下侧for循环不执行)

3.只有一行元素  就是我们可以顺时针打印 上面 和 左面的部分,此时条件是 宽若干长1  (width-2i大于1且length-2i==1)

类似一行的情况,要给左侧for循环加判断条件  if(长度为1可以不打左侧,因为右侧打完了)

ok,那基于上面的分析我们知道了只要下一圈有元素,我们就可以i++,四个for遍历下一圈,加上我们的if条件。即使出现特殊情况也不必担心。

那下一圈有元素的条件就是非没有元素的条件(length-2*i>0)&&(width-2*i>0)

综上所述,总结一下 对于单行、单列要考虑左右、上下打印条件的相互制约。

给出代码和运行截图:

 1 class Solution {
 2 public:
 3     static vector<int> printMatrix(vector<vector<int> > matrix) {
 4         if (matrix.size() == 0) return vector<int>();
 5         int width = matrix.size(), length = matrix[0].size();//r,c为矩阵长宽
 6         int i = 0;
 7         vector<int> result;
 8         while ((length - 2 * i > 0) && (width - 2 * i > 0))
 9         {
10             //上侧
11             for (int j = i; j <= length - i - 1; j++) {
12                 result.push_back(matrix[i][j]);
13             }
14
15             //右侧
16             for (int j = i + 1; j <= width - i - 1; j++) {
17                 result.push_back(matrix[j][length - i - 1]);
18             }
19             //下侧
20             if (width - 2 * i != 1) {//宽度为1不要有右到左打印一遍了,上侧已经打了
21                 for (int j = length - i - 2; j >= i; j--) {
22                     result.push_back(matrix[width - i - 1][j]);
23                 }
24             }
25             //左侧
26             if (length - 2 * i != 1) {//长度为1不要再由下到上打印一遍了,右侧从上到下打了
27                 for (int j = width - i - 2; j > i; j--) {
28                     result.push_back(matrix[j][i]);
29                 }
30             }
31             i++;
32
33         }
34         return result;
35     }
36
37 };

运行截图:

附上一个小知识点:vectot<int> 的push_back函数会像数组尾部填数据。预先申请好大小后vector<int> a(5); 用 push_back时会扩容的去填,前面的5个数都是0。

我误认为要先申请空间才能向里添加数据了。

最后,感谢阅读文章,如有疏漏,欢迎指正。

现在转了一圈,要结束了,结束时会出现四种可能,一行、一列、一个、无元素

对于一行的情况,其条件是只

原文地址:https://www.cnblogs.com/linxuesong/p/11733488.html

时间: 2024-10-12 16:42:11

剑指Offer(十九)——顺时针打印矩阵的相关文章

剑指offer之【顺时针打印矩阵】

题目: 顺时针打印矩阵 链接: https://www.nowcoder.com/practice/9b4c81a02cd34f76be2659fa0d54342a?tpId=13&tqId=11172&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking 题目描述: 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下矩阵: 1 2 3 4 5 6 7

剑指Offer对答如流系列 - 顺时针打印矩阵

面试题29:顺时针打印矩阵 题目描述 输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字. 比如:输入以下矩阵 打印出的数字为1 2 3 4 8 12 16 15 14 13 9 5 6 7 11 10 问题分析 每次打印都是打印外面的一圈,每次打印矩阵的起点横纵坐标都相同(横纵坐标值均设置为start),其余三个角的坐标都与start有关. 对于start而言,start*2的值小于行数和列数时才需要继续打印. 这样一分析,发现整个数学模型都建立起来了. 问题解答 public vo

剑指offer系列——19.顺时针打印矩阵

Q:输入一个矩阵,按照从外向里以顺时针的顺序依次打印出每一个数字,例如,如果输入如下4 X 4矩阵: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10. A: vector<int> printMatrix(vector<vector<int> > matrix) { int size1 = matrix[0].size(); //列数 int si

剑指offer python版 顺时针打印矩阵

def aa(matrix): rows=len(matrix) cols=len(matrix[0]) start=0 ret=[] while start*2 <rows and start*2<cols: bb(matrix,rows,cols,start,ret) start +=1 return ret def bb(matrix,rows,cols,start,ret): row=rows-start-1 col=cols-start-1 for c in range(start,

剑指offer | 从尾到头打印链表

题目描述: “输入一个链表,从尾到头打印链表每个节点的值.” 这是我做的<剑指offer>系列的第一题,好的开头就是成功的一半.然而,我提交了一次,WA!再提交,WA!Com'on! 看来我的开端并不顺利.不过我要的可不是成功的一半,这样的开端怎么能阻挡我AC之路!仔细看了一遍题目要求,看了提交格式.再提交! Finally,AC! 代码如下: 1 /** 2 * struct ListNode { 3 * int val; 4 * struct ListNode *next; 5 * Lis

剑指offer(十六) 合并两个排序的链表

合并两个排序的链表 题目描述 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 用JavaScript非递归和递归方式都AC了. 非递归: function ListNode(x){ this.val = x; this.next = null; } function Merge(pHead1, pHead2) { if(!pHead1) { return !pHead2 ? null:pHead2; }else if(!pHead2) { retur

[剑指Offer] 60.把二叉树打印成多行

题目描述 从上到下按层打印二叉树,同一层结点从左至右输出.每一层输出一行. [思路]使用队列实现二叉树的层次遍历. 1 /* 2 struct TreeNode { 3 int val; 4 struct TreeNode *left; 5 struct TreeNode *right; 6 TreeNode(int x) : 7 val(x), left(NULL), right(NULL) { 8 } 9 }; 10 */ 11 class Solution 12 { 13 public:

剑指offer——从尾到头打印链表节点的值

输入一个链表,从尾到头打印链表每个节点的值. 输入描述:输入为链表的表头 输出描述:输出为需要打印的“新链表”的表头 一.问题分析 初拿到这个题目时,这应该是考察单向链表这一数据结构.单向链表的遍历总是从头指针逐项遍历各个节点,现在要求从尾到头打印节点的值,我们可以在遍历时把各节点压入栈内,最后出栈打印各个节点值,即可达到要求. 实现之前,我们先来看看如何创建一个链表. 1,链表节点的数据结构定义 1 struct ListNode { 2 int val; 3 struct ListNode

剑指Offer —— BFS 宽度优先打印

https://www.nowcoder.net/practice/7fe2212963db4790b57431d9ed259701?tpId=13&tqId=11175&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking 题目描述 从上往下打印出二叉树的每个节点,同层节点从左至右打印. /* struct TreeNode { int val; struc

剑指offer —— 从尾到头打印链表

1.问题:输入一个链表,从尾到头打印链表每个节点的值. /** * public class ListNode { * int val; * ListNode next = null; * * ListNode(int val) { * this.val = val; * } * } * */ import java.util.ArrayList; public class Solution { public ArrayList<Integer> printListFromTailToHead