跟英雄哪里出来练习算法

学习目标：

例如：

• 算法每日练习：英雄每日直播题目+lecode每日一题

---

题目：

题目链接	难度
707.链表	中等
2326.螺旋矩阵	中等
1252.奇数数目	简单

---

算法思路：

1.链表增删改查

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

class ListNode:
    def __init__(self,x):
        self.val = x
        self.next = None
class MyLinkedList:
    def __init__(self):
        self.size = 0
        self.head = ListNode(0)
    /当索引合理时，找到对应节点输出值
    def get(self, index):
        if index<0 or index>=self.size:
            return -1
        curr = self.head
        for _ in range(index+1):
            curr = curr.next
        return curr.val
    /等同于在index前插入，直接调用addAtIndex
    def addAtHead(self, val):
        self.addAtIndex(0, val)
    /等同于在index前插入，直接调用addAtIndex
    def addAtTail(self, val):
        self.addAtIndex(self.size, val)
    def addAtIndex(self, index, val):
        /题目要求，索引小于0时与等于0等同
        if index<0:
            index=0
        if index >self.size:
            return
        self.size +=1
        curr = self.head
        for _ in range(index):
            curr = curr.next
        /声明新节点用于插入，找到索引节点的前一个结点，先指向索引结点，再让当前结点指向插入节点
        addNode = ListNode(val)
        addNode.next = curr.next
        curr.next = addNode
    /找到索引结点的前一个结点作为当前结点，当前节点直接指向索引结点的下一个    
    def deleteAtIndex(self,index):
        if index<0 or index>=self.size:
            return
        self.size -=1
        curr = self.head
        for _ in range(index):
            curr = curr.next
        curr.next = curr.next.next

2.螺旋矩阵：

给你两个整数：m 和 n ，表示矩阵的维数。

另给你一个整数链表的头节点 head 。

请你生成一个大小为 m x n 的螺旋矩阵，矩阵包含链表中的所有整数。链表中的整数从矩阵 左上角 开始、顺时针 按 螺旋 顺序填充。如果还存在剩余的空格，则用 -1 填充。

返回生成的矩阵。

class Solution:
    def spiralMatrix(self, m: int, n: int, head: Optional[ListNode]) -> List[List[int]]:
        /用于判断对应位置是否已经存入过，默认为0，存入后改为1
        hash = [0]*100010
        /方向矩阵，依次为向右，向下，向左，向上
        dir = [[0,1],[1,0],[0,-1],[-1,0]]
        /结果列表，维度m*n,默认值为-1
        res =[[-1 for i in range(n)] for i in range(m)]
        i, j, d = 0, 0, 0
        /当前结点不为None
        while head:
            /存入
            res[i][j] = head.val
            hash[i*n +j] = 1
            i += dir[d][0]
            j +=dir[d][1]
            /转向次数
            dcont = 0
            /当列表下标不在范围，或这个位置已经存入过。回退并转向
            while(i>=m or i<0 or j<0 or j>=n or hash[i*n +j] == 1):
                i -= dir[d][0]
                j -=dir[d][1]
                d = (d+1)%4
                i += dir[d][0]
                j +=dir[d][1]
                dcont +=1
                /转向大于四次，矩阵已经存满退出
                if dcont==5:
                    break
            head = head.next
        return res

1252.奇数单元格数目：

给你一个 m x n 的矩阵，最开始的时候，每个单元格中的值都是 0。

另有一个二维索引数组 indices，indices[i] = [ri, ci] 指向矩阵中的某个位置，其中 ri 和 ci 分别表示指定的行和列（从 0 开始编号）。

对 indices[i] 所指向的每个位置，应同时执行下述增量操作：

ri 行上的所有单元格，加 1 。
ci 列上的所有单元格，加 1 。
给你 m、n 和 indices 。请你在执行完所有 indices 指定的增量操作后，返回矩阵中 奇数值单元格 的数目。

class Solution:
    def oddCells(self, m: int, n: int, indices: List[List[int]]) -> int:
        /初始化结果列表
        resList = [[0 for j in range(n)]for i in range(m)]
        res = 0
        for i in range(len(indices)):
            for j in range(n):
                resList[indices[i][0]][j] +=1
            for z in range(m):
                resList[z][indices[i][1]] +=1
        /统计奇数个数
        for i in range(m):
            for j in range(n):
                if resList[i][j] % 2:
                    res +=1
        return res

---

原来直接从lecode复制粘贴和手打代码颜色不一样