学习笔记@代码随想录day3:链表part01-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40357993/article/details/131717720

学习笔记@代码随想录day3:链表part01

昨日问题

长度最小的子数组

昨天的长度最小的子数组中的代码出现问题，发现是代码中一个小细节写错了，正确写法应该如下：

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        i=0#起始位置
        sum_list=0#用于求子数组的和
        min_s=10^9#假设初始的子数组长度为这么大
        for j in range(len(nums)):
        #while j<len(nums):
            #j表示终止位置
            sum_list+=nums[j]
            while sum_list>=target:      
                subl=j-i+1      
                #当和大于目标值的时候，求子数组的长度并和当前最小的子数组比较，选择最小的子数组
                min_s=min(min_s,subl)
                sum_list=sum_list-nums[i]#此时已经达到条件，要开始查找下一个子数组，初值指针移动一位，所以要减去前一个值
                #昨天把这里写成了i=+1!!!!!!!
                i += 1
        return min_s

出错在把代码中的i+=1写成i=+1，相当于i一直不变等于正1。o(╥﹏╥)o
但是改了以后依旧存在问题，对于输入例11，[1,1,1,1,1,1,1,1]报错，查找了下原因，是我min_s初始值的原因。
参照代码随想录的代码，改了初始值的设置，float(‘inf’)表示正无穷大的浮点数。运行通过！

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        i=0#起始位置
        sum_list=0#用于求子数组的和
        min_s= float('inf')#假设初始的子数组长度为这么大
        for j in range(len(nums)):
        #while j<len(nums):
            #j表示终止位置
            sum_list+=nums[j]
            while sum_list>=target:      
                subl=j-i+1      
                #当和大于目标值的时候，求子数组的长度并和当前最小的子数组比较，选择最小的子数组
                min_s=min(min_s,subl)
                sum_list=sum_list-nums[i]#此时已经达到条件，要开始查找下一个子数组，初值指针移动一位，所以要减去前一个值
                i += 1
        if min_s== float('inf'):
            min_s=0
        return min_s
        ##最后的判断返回可改写为return min_len if min_len != float('inf') else 0

螺旋矩阵

昨天没来得及自己手撸一下螺旋矩阵的代码，今天补上

class Solution:
    def generateMatrix(self, n: int) -> List[List[int]]:
        starx=0
        stary=0
        #每填完一层的初始值，比如n=5的时候，要填两个正方形的数，填完第一层时，每条变会有对应的变化
        #第一条边y-offset,第二条边x-offset,第三条边y+offset,第四条边x+offset
        offset=1
        count=1
        #初始值， 1 到 n**2,所以初始值为1
        #迭代次数,这里是通过推算来的，n=3时迭代1次，中间填一个数。n=4时迭代2次。n=5时迭代2次，中间填一个数……
        d_time=n//2
        result=[[0 for j in range(n)] for i in range(n)]
        l=n
        while count<n**2:
            #上,x变，y不变,填n-1个数，左闭右开原则
            for i in range(n-offset):
            # print(i,stary)
                result[starx][i]=count
                count+=1
            #print('上',result)
            #右，x不变，y变,这里要注意起点
            for i in range(n-offset):
                #result[starx][i]=count
                result[i][starx+(n-offset)]=count
                count+=1
            #print('左',result)
            #下，x变，y不变,起点变为右下角的点
            for i in range(n-offset):
                result[starx+(n-offset)][(n-offset)-i]=count
                count+=1
           # print('下',result)
            #下，x不变，y变，起点为左下的点
            for i in range(n-offset):
                result[(n-offset)-i][starx] = count
                count += 1
            #print('右',result)
            offset+=1
            starx+=starx+offset
            stary+=stary+offset
        if n%2==1:
            result[n-2][n-2]=n**2
        return result

总结挺简单的算法思想，但是写的过程中老是会出错

移除链表元素

链表

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。
在这里插入图片描述
上述为单链表，双链表可向前查询也可向后查询

循环链表

数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。

链表是通过指针域的指针链接在内存中各个节点。

所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。
删除链表节点：指针指向删除节点的下一个节点。
增加节点：上一个节点指针指向增加节点，增加节点指针指向下一个节点。
链表定义：

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next
'''
这段代码定义了一个名为ListNode的类，该类包含两个属性：
val和next。val表示节点的值，next表示节点的下一个节点。
这个类可以用来创建一个链表数据结构，其中每个节点都包含一个值和一个指向下一个节点的指针。

具体来说，这个类的构造函数__init__接受两个参数：val和next。
val参数表示节点的值，next参数表示指向下一个节点的指针。
如果没有指定next参数，则默认为None。
'''

删除链表操作的两种方式：

a.直接使用原来的链表来进行删除操作。
b.设置一个虚拟头结点再进行删除操作。
如果直接再原来的链表上进行删除操作，头节点的操作跟其他节点操作不一样，需要单独处理。
所以设置一个需里头检点再进行删除删除操作更好。
代码思想：
1.为当前链表增加一个头头节点，头节点指向当前列表的头节点
2.循环遍历，查找需要删除的值，将删除值的上一个节点指向删除值下一个节点
3.完成循环后，返回虚拟节点的next即为整个删除后的链表

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        # 创建虚拟头部节点以简化删除过程
        dummy_head = ListNode(next = head)
        
        # 遍历列表并删除值为val的节点
        current = dummy_head
        while current.next:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next
        
        return dummy_head.next