第三天 | 203 移除链表元素 704.设计链表 206.反转链表

203.移除链表元素

题目描述：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

思路：

题解上有两种： 一是根据原来的链表进行直接删除。二是设置一个虚拟头结点来进行删除操作。

在leetcode上还看到一种熟悉的方法 双指针法，感觉比较好。这题的思路可以设置一个虚拟头结点，使它的链表下一个元素是原链表的头结点，！！一定要定义一个临时指针做循环，不能直接用head改变，head一旦改变就找不到了。遍历链表并删除值为val的结点，最后记得返回虚拟链表的下一个元素，才能是原来链表移除后的新链表。

# 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:
            if cur.next.val==val:
                cur.next=cur.next.next
            else:
                cur=cur.next
        return dummy_head.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]:
        while head and head.val==val:
            head=head.next
        pre,cur=head,head
        while pre:
            if pre.val==val:
                cur.next=pre.next
            else:
                cur=pre
            pre=pre.next
        return head

时间复杂度：O(n)

704.设计链表

题目描述：

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

• MyLinkedList() 初始化 MyLinkedList 对象。
• int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
• void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
• void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
• void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
• void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

思路：勉强看懂吧

pre.next = ListNode(val, pre.next)的意思分为两步

1. 新节点为 ListNode()，指向 pre 的下一个节点，所以是 ListNode(val, pre.next)
2. pre 指向新节点，所以是 pre.next = ListNode(val, pre.next)

代码可能有点错，下面还有大佬的代码。。。

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

    def __init__(self):
        self.dummy=ListNode()
        self.size=0
    def get(self, index: int) -> int:
        if index<0 or index>self.size-1:
            return -1
        cur=self.dummy.next
        for i in range(index):
            cur=cur.next
        return cur.val

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

    def addAtTail(self, val: int) -> None:
        cur=self.dummy
        while cur.next:
            cur=cur.next
        cur.next=ListNode(val)
        self.size+=1
    def addAtIndex(self, index: int, val: int) -> None:
        if index<0 or index>=self.size:
            return 
        cur=self.dummy
        for i in range(index):
            cur=cur.next
        cur.next=ListNode(val,cur.next)
        self.size+=1

    def deleteAtIndex(self, index: int) -> None:
        if index<0 or index>=self.size:
            return
        cur=self.dummy
        for i in range(index):
            cur=cur.next
        cur.next=cur.next.next
        self.size-=1

class MyLinkedList:

    def __init__(self):
        self.dummy = ListNode()
        self.cnt = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.cnt:
            return -1
        cur = self.dummy.next
        for _ in range(index):
            cur = cur.next
        return cur.val

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

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

    def addAtIndex(self, index: int, val: int) -> None:
        if index > self.cnt:
            return
        pre = self.dummy
        for _ in range(index):
            pre = pre.next
        pre.next = ListNode(val, pre.next)
        self.cnt += 1

    def deleteAtIndex(self, index: int) -> None:
        if index >= self.cnt:
            return
        pre = self.dummy
        for _ in range(index):
            pre = pre.next
        t = pre.next
        pre.next = t.next
        t.next = None
        self.cnt -= 1

作者：ylb
链接：https://leetcode.cn/problems/design-linked-list/solutions/1842950/by-lcbin-159n/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

        new_Node=self.dummy.next

        self.dummy.next=ListNode(val,new_Node)

将dummy结点的next指针指向的节点赋值给new_Node，相当于将原来链表中的头结点储存在new_Node中，然后创建一个ListNode对象，值为val，将新结点的next指向new_Node，原来dummy结点的next指针指向这个节点。实现在链表头部插入新节点

206.反转链表

题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：可以用双指针（迭代）法进行遍历，先初始化指针pre,cur分别指向头结点和null，定义一个tmp用于储存后续结点，将cur.next指向pre，此时已经反转了第一个指向，继续移动pre和cur指针，最后返回。

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        cur, pre = head, None
        while cur:
            tmp = cur.next  # 暂存后继节点 cur.next
            cur.next = pre  # 修改 next 引用指向
            pre = cur       # pre 暂存 cur
            cur = tmp       # cur 访问下一节点
        return pre

还有递归法

一. reverseList函数接收一个头节点head作为参数，然后调用内部的reverse函数进行链表反转操作

二.   函数首先检查当前节点cur是否为空，如果为空则返回前一个节点pre，表示已经处理完整个链表，可以返回反转后的链表头节点。如果当前节点不为空，则进行以下操作：

1. 将当前节点cur的下一个节点暂存为temp。
2. 将当前节点cur的next指针指向前一个节点pre，实现反转操作。
3. 递归调用reverse函数，将temp作为当前节点，cur作为前一个节点继续反转操作。

通过不断递归调用reverse函数，直到遍历完整个链表，完成链表的反转操作。最终返回反转后的链表头节点。

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