leetcood学习笔记-54-螺旋矩阵

题目描述：

第一次提交:

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        j,x = 0,1
        l = []
        if matrix==[]:
            return []
        m = len(matrix)
        n = len(matrix[0])
        while x<=n*m:
            for i in range(j,n-j):
                l.append(matrix[j][i])
                x += 1
            for i in range(j+1,m-j):
                l.append(matrix[i][n-j-1])
                x += 1
            if x <= n * m:
                for i in range(n-j-2,j-1,-1):
                    l.append(matrix[m-j-1][i])
                    x += 1
                for i in range(m-j-2,j,-1):
                    l.append(matrix[i][j])
                    x += 1
            j += 1
        return l

另：

class Solution:
    def spiralOrder(self, matrix:[[int]]) -> [int]:
        if not matrix: return []
        l, r, t, b, res = 0, len(matrix[0]) - 1, 0, len(matrix) - 1, []
        while True:
            for i in range(l, r + 1): res.append(matrix[t][i]) # left to right
            t += 1
            if t > b: break
            for i in range(t, b + 1): res.append(matrix[i][r]) # top to bottom
            r -= 1
            if l > r: break
            for i in range(r, l - 1, -1): res.append(matrix[b][i]) # right to left
            b -= 1
            if t > b: break
            for i in range(b, t - 1, -1): res.append(matrix[i][l]) # bottom to top
            l += 1
            if l > r: break
        return res

笔记：

Python List extend()方法

 Python 列表

---

描述

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

语法

extend()方法语法：

list.extend(seq)

---

二、python中sorted和.sorted 、reversed和reverse的注意点

L=[1,2,3,4]
l1=[123,123,23]
if l1.sort() == L.reverse():   #这个判断式是恒等的，因为两个函数的返回值都是None（其实是无返回值）
    print(1)

------------------------------------------------------------

a.sort()是对列表a进行原地修改，而且只能修改列表

而sorted（a）对字符串、列表、元组都能排序，该函数返回一个排序好的列表（都是列表！！）

------------------------------------------------------------

个人感觉reverse没什么diao用、当然原地修改还是要用reverse()的

因为对于字符串、列表、元组来说都可以用a[::-1]来取反

要注意a[::-1]返回的是一个逆转的列表、字符串、元组。并不是对a的原地修改

还有一种方法就是用.sort(reverse=1)来取反

-------------------------------------------------------------

.reverse()无返回值

使用reversed（）返回一个迭代器(迭代器的意思是只能通过循环来输出）
a = '321'
b = reversed(a)
print(b)

>>> <reversed object at 0x02E2B090>

显示的是返回了一个迭代器

迭代器用循环输出

for i in b:

　　print(i,end =' ')

>>> 1  2 3

为什么会和sorted不同呢

------------------------------------------------------------

用for i in reversed(a):

　　print(i)

发现数据输出竖着输出

改一个参数print(i,end=' ')将末尾的换行符\n换成‘ ’这样就不会自动换行了

---

三、python中zip()与zip(*)的用法解析

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 打包为元组的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压，为zip的逆过程，可用于矩阵的转置
[(1, 2, 3), (4, 5, 6)]

详见：

https://www.cnblogs.com/waltsmith/p/8029539.html

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        # 取首行，去除首行后，对矩阵翻转来创建新的矩阵，
        # 再递归直到新矩阵为[],退出并将取到的数据返回
        ret = []
        if matrix == []:
            return ret
        ret.extend(matrix[0]) # 上侧
        new = [reversed(i) for i in matrix[1:]]
        if new == []:
            return ret
        r = self.spiralOrder([i for i in zip(*new)])
        ret.extend(r)
        return ret

附：矩阵逆时针旋转代码：

matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
new = [reversed(i) for i in matrix[:]]
new = [i for i in zip(*new)]

java通过两次翻转，实现原地旋转

class Solution {
    public void rotate(int[][] matrix) {
        int n = matrix.length;
        for(int i = 0; i<n-1;i++){
            for(int j = i+1;j<n;j++){
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[j][i];
                matrix[j][i] = tmp;
            }
        }
        int mid = n>>1;
        for(int i = 0;i<n;i++){
            for(int j = 0;j<mid;j++){
                int tmp = matrix[i][j];
                matrix[i][j] = matrix[i][n -1 - j];
                matrix[i][n-1-j] = tmp;
            }
        }
    }
}

另：

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        res = []
        while matrix:
            res += matrix.pop(0)
            matrix = list(zip(*matrix))[::-1]
        return res