代码随想录算法训练营Day3-203.移除链表元素、707.设计链表、206.反转链表

链表理论基础

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向None（空指针的意思）

链表的入口节点称为链表的头结点也就是head
链表分为单链表、双链表、循环链表，如下图



链表是通过指针域的指针链接在内存中各个节点。所以链表中的节点在内存中不是连续分布的 ，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理

在python中，链表可以进行如下定义：

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

实例化一个链表

# 定义头结点并初始化
head_value = 5
head = ListNode(head_value)

# 构造初始化节点
node1 = ListNode(1)
node2 = ListNode(2)
node3 = ListNode(3)

# 将节点连接起来
head.next = node1
node1.next = node2
node2.next = node3

链表中常用虚拟头结点来解题

dummy_head = ListNode(next = head)

707.设计链表

对于链表的理解可以从707.设计链表这道题开始理解，包括了链表的多个操作

题目链接/文章讲解/视频讲解：https://programmercarl.com/0707.%E8%AE%BE%E8%AE%A1%E9%93%BE%E8%A1%A8.html
在链表类中实现这些功能：

**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, value=0, next=None):
        self.value = value
        self.next = next

然后再去设计MyLinkedList类

class MyLinkedList:
    def __init__(self):
        self.dummy_head = ListNode() 
        self.size = 0  

    def get(self, index: int) -> int:

    def addAtHead(self, val: int) -> None:

    def addAtTail(self, val: int) -> None:

    def addAtIndex(self, index: int, val: int) -> None:

    def deleteAtIndex(self, index: int) -> None:

设计def get(self, index: int) -> int:获取链表中第 index 个节点的值。如果索引无效，则返回-1
链表不能像数组一样直接获取，需要从头结点开始遍历，所以使用for i in range(index)来遍历

def get(self, index: int) -> int:		
		# 通常头结点索引为0，index >= self.size也是无效索引，这里符号需要注意
        if index < 0 or index >= self.size:
            return -1
		# 遍历节点
        current = self.dummy_head.next
        for i in range(index):
            current = current.next
        # 当前指针在第index个节点处 直接获取值
        return current.value

def addAtHead(self, val: int) -> None:将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。新节点即dummy_head.next ，它的下一个节点是原先dummy_head.next。添加完注意链表长度+1

def addAtHead(self, val: int) -> None:
        self.dummy_head.next = ListNode(val, self.dummy_head.next)
        self.size += 1

def addAtTail(self, val: int) -> None:将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
一直遍历到某个节点的下一个节点为None,此时已经到达链表末尾，在后面添加，添加记得size + 1

def addAtTail(self, val: int) -> None:
        current = self.dummy_head
        while current.next != None:
            current = current.next
        current.next = ListNode(val, next = None)
        self.size += 1

def addAtIndex(self, index: int, val: int) -> None: 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入到链表中。
要插入到index节点之前，可以从虚拟头结点开始遍历

def addAtIndex(self, index: int, val: int) -> None:
		# index=size,添加到末尾，这里也是需要注意这个是>还是>=
        if index <0 or index > self.size:
            return 

        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = ListNode(val, current.next)
        self.size += 1

def deleteAtIndex(self, index: int) -> None:如果下标有效，则删除链表中下标为 index 的节点。注意size-1

 def deleteAtIndex(self, index: int) -> None:
        if index <0 or index >= self.size:
            return 

        current = self.dummy_head
        for i in range(index):
            current = current.next
        current.next = current.next.next
        self.size -= 1

这样就完成单链表的一些设计了。在这道题中我遇到的最大地问题是对于有关index的操作，是从虚拟头结点开始呢，还是头结点开始，是index >= self.size还是index > self.size，这两点需要理清楚才能保证设计的链表正确！

203.移除链表元素

题目链接/文章讲解/视频讲解：：https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html

题意：删除链表中等于给定值 val 的所有节点。
示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]
示例 2： 输入：head = [], val = 1 输出：[]
示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

思路：
已经设计过链表了，这题就很简单啦

移除操作就是当前指针指向下下个节点就好

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next = head) 
        current = dummy_head
        
        while current.next != None:
            if current.next.val == val:
                current.next = current.next.next
            else:
                current = current.next
        
        return dummy_head.next

在链表中，返回头结点，就能输出整个链表啦！

206.反转链表

题目链接/文章讲解/视频讲解：https://programmercarl.com/0206.%E7%BF%BB%E8%BD%AC%E9%93%BE%E8%A1%A8.html

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

思路：
直接看讲解的。

双指针法
首先定义一个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]:
        current = head
        pre = None
        while current != None:
            temp = current.next
            current.next = pre
            pre = current
            current = temp
        return pre

递归法

递归法相对抽象一些，但是其实和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程。

关键是初始化的地方，可能有的同学会不理解， 可以看到双指针法中初始化 cur = head，pre = NULL，在递归法中可以从如下代码看出初始化的逻辑也是一样的，只不过写法变了

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
    	return self.reverse(head, None)
    def reverse(self, current:Optional[ListNode], pre:Optional[ListNode])  -> Optional[ListNode]:
	    if current == None:
		    return pre
	    temp = current.next
	    current.next = pre
	    return self.reverse(temp, current)	

感觉理清楚节点的下一个指向是什么是很重要的！