代码随想录算法训练营第三天|203.移除链表元素、206.反转链表、707.设计链表-CSDN博客

本文链接：https://blog.csdn.net/qq_52184734/article/details/127985544

知识点学习：Python链表定义

1、节点类定义。我们将节点类定义成ListNode，定义了两个属性，其中val用来存储节点的值，next用来存储下一个节点的索引：

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

2、定义一个节点。如下创建了两个个独立的节点：

node1 = Node(data=1)
node2 = Node(2)

print(node1.data) #1
print(node2.data) #2

3、然后再把节点关联起来

node1.next = node2

注意：此处要理解python存储本质：

根据python中“一切皆对象”，因此node1.next存储的是node2的地址

203.移除链表元素

题目链接：203.移除链表元素

思路

增加一个虚拟头结点，这样删除原始头结点也会和其他节点一样的方法

代码

# 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: ListNode, val: int) -> ListNode:
        dummy_head = ListNode(next=head) #添加一个虚拟节点
        cur = dummy_head
        while(cur.next!=None):
            if(cur.next.val == val):
                cur.next = cur.next.next #删除cur.next节点
            else:
                cur = cur.next
        return dummy_head.next

反思

1. 对于cur向下迭代处代码的疑问

这两个有什么区别呢？

#1
cur.val=cur.next.val
cur.next=cur.next.next
#2
cur=cur.next

于是画了个图

对于第一种来说，只改变了cur节点的属性，这样的问题就是虽然最后遍历完了，但dummy_head指向的就是最后的一个节点，输出的dummy_head.next就是none。

对于第二种，则直接改变了cur存储的地址。并且在第一步中，由于这边是浅拷贝，因此dummy_head也更新了存储的地址。

2. 对于dummy_head和cur的疑问
一开始不太能想想的出来为什么最后返回的是dummy_head.next

#返回新的头结点
return dummy_head.next

也是画了个图

看这个图就很明显了

206.反转链表

题目链接：206.反转链表

思路

首先定义一个cur指针，指向头结点，再定义一个pre指针，初始化为null。然后把cur->next 节点用tmp指针保存一下。

——为什么要保存一下这个节点呢，因为接下来要改变 cur->next 的指向了，将cur->next 指向pre 。

接下来，就是循环走如下代码逻辑了，继续移动pre和cur指针。

最后，cur 指针已经指向了null，循环结束，链表就反转完毕了。此时return pre指针，pre指针就指向了新的头结点。

代码

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while(cur!=None):
            tmp = cur.next
            cur.next=pre
            pre = cur
            cur = tmp
        return pre

707.设计链表

题目链接：707.设计链表

代码

# 单链表
class Node:

    def __init__(self,val):
        self.val=val
        self.next=None

class MyLinkedList:

    def __init__(self):
        self.head=Node(0)
        self.count=0

    def get(self, index: int) -> int:
        #get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1
        cur=self.head
        if 0 <= index < self.count:
            for _ in range(index+1):## 注意是index+1
                cur=cur.next
            return cur.val
        else:
            return -1

    def addAtHead(self, val: int) -> None:
        #addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点
        self.addAtIndex(0,val)


    def addAtTail(self, val: int) -> None:
        #addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素
        self.addAtIndex(self.count,val)

    def addAtIndex(self, index: int, val: int) -> None:
        #addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点
        if index > self.count:
            return
        index=max(0,index)
        self.count+=1
        add_node=Node(val)
        pre_node=self.head
        for _ in range(index):
            pre_node=pre_node.next
        add_node.next=pre_node.next
        pre_node.next=add_node
        

    def deleteAtIndex(self, index: int) -> None:
        #deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点
        if 0<= index < self.count:
            self.count-=1
            pre_node=self.head
            for _ in range(index):
                pre_node=pre_node.next
            pre_node.next=pre_node.next.next
        else:
            return

反思

get()
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1

唯一容易错的地方就是这里遍历次数是index+1，图可以看出是第index+1次才遍历到下标为index的数值

for _ in range(index+1):## 注意是index+1

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

可见有三种情况，但是代码里只有一个index大于链表的情况单独拎出来了，也就是说其他两种情况都是可以和普通增加情况一样的

for _ in range(index): # index<0 与 index=self.count 也是这样遍历
            pre_node=pre_node.next
        add_node.next=pre_node.next
        pre_node.next=add_node