代码随想录算法训练营Day3：链表（Python力扣● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表 ）

代码随想录算法训练营Day3：链表（Python力扣● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表 ）

1.链表基础（python）

（1）创建链表

链表的第一基础就是学会创建链表，虽然力扣刷题不用直接创立链表，但笔试的ACM模式要求我们去手把手创建列表（还有ACM的模式下input，这个也很重要，到时候会总结一遍博客关于python 中input的在笔试中常用的用法）

力扣第一遍刷链表题的时候就对链表的创建比较迷惑。
python 代码如下

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

（2） 链表的常用的操作

I. 删除节点

如果要删除D节点，只需要将C的Next指针指向E的头结点即可。
在python中有回收机制，所以Python中我们在编程的时候就不用管被删除的节点啦。

其次在通常有两种方法对链表进行删除:
一是直接对原链表进行操作，但是头结点删除时需要特殊操作，这样会导致代码看的不那么简洁
二是创建一个虚拟头结点，连接原链表的头结点，这样在进行链表删除操作时，不管是删除头结点还是中间节点都会是同样的代码操作，会使得代码看起来非常简洁。
下面的python代码也都是用这种方法

II.添加节点

示意图如下：

例如添加F节点，只有先将F的Next指针指向D的头结点，然后再将C的Next指针指向F的头结点，这个顺序很重要。

2. 力扣203.移除链表元素 （python程序和思路）

该题思路：
这题相对来说较为简单一点，
（1）看到有删除节点的操作，先创建一个虚拟头结点，它的Next指针指向真正的头结点。
（2）遍历整个列表，对val值相等的进行删除，其中删除操作就是cur.next = cur.next.next
（3）返回虚拟头结点的next（这个很重要，返回值不要返回错误）

注意：链表的遍历方法，如下边编码，用while循环

python代码如下

```python
# 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)      #创建一个虚拟头结点
        cur = dummy_head                   
        while(cur.next != None):              #对链表进行遍历
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next        #请记住返回的是虚拟头结点的Next

3. 力扣 707.设计链表（python程序和思路）

思路：
设计链表包含了好几种链表的常用操作，分开都不算太难，但合在一起就有一点绕。
注意:
（1）遍历链表时，while (cur.next)和while（cur.next ！= None）是一样的
（2）下面所有方法都采用了虚拟头结点的方法，所以在定义MyLinkedList类时就先定义了虚拟头结点。
（3）addAtIndex 方法中描述的“如果 index 等于链表的长度，则该节点将附加到链表的末尾” 这句话中 链表长度这里是指 size而不是size - 1，如果是size-1的话那就会和在最后一个元素前插入冲突了。
（有代码有关的疑惑可以在评论区讨论，我会一一解答）

class Node(object):
    def __init__(self,x = 0):
        self.val = x
        self.next = None

class MyLinkedList(object):

    def __init__(self):
        self.head = Node()                            #虚拟头结点
        self.size = 0

    def get(self, index: int) -> int:
        if index<0 or index>=self.size:
            return -1
        cur = self.head.next
        while (index):
            cur = cur.next
            index -= 1
        return cur.val


    def addAtHead(self, val: int) -> None:
        newcode = Node(val)
        newcode.next = self.head.next
        self.head.next = newcode
        self.size += 1

    def addAtTail(self, val: int) -> None:
        newcode = Node(val)
        cur = self.head
        while(cur.next != None):
            cur = cur.next
        cur.next = newcode
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0:
            self.addAtHead(val)
            return
        if index == self.size:
            self.addAtTail(val)
            return
        elif index > self.size:
            return
        newnode = Node(val)
        cur = self.head                          #不对原始链表进行操作
        while (index):
            cur = cur.next
            index -= 1
        newnode.next = cur.next
        cur.next = newnode
        self.size += 1

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

3. 力扣 206.反转链表（python程序和思路）

思路：
双指针法，先用一个指针记录当前节点（cur）的next，然后将当前指针的next指向pre（当前节点的前一个节点），然后先移动pre，在移动cur，这个顺序很重要，不能出错。

注意：
遍历指针有时候需要判定cur.next !=none，有时候又不需要 ，只用判断cur!=none呢？其实这个要看场景，一般就是看你如果不判断的话会不会导致空指针异常，因为如果你的指针遍历到null还调用它的属性或方法肯定就会报错的，但是有时候的情况不会遍历到cur->next，所以要看具体情况。

双指针法：

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        cur = head                #初始节点
        pre = None
        while (cur):
            temp = cur.next       #记录下一个节点
            cur.next = pre
            pre = cur             #移动双指针
            cur = temp
        return pre

递归法：
注意:递归法的思路完全是按照双指针法的逻辑来进行改编的

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