代码随想录day3 203.移除链表元素 707.设计链表 206.反转链表

由于回学校所以耽误了几天 今天补上

203 移除链表元素：

题目链接：203. 移除链表元素 - 力扣（LeetCode）

参考资料：代码随想录 (programmercarl.com)

思路：本题需要移除链表中等于val的元素 而头结点就可能存在等于val的情况存在 这时候就不能直接移除 因为链表的移除是通过前一个元素 头结点没有前一个元素 所以我们创造一个虚拟头结点dummy_head 让current等于dummy_head 最后用while循环遍历 如果等于就移除 循环一次后让current=current.next 即为让current移动一次

下面为代码示例

# 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)
        current=dummy_head
        while current.next:
            if current.next.val==val:
                current.next=current.next.next
            else:
                current=current.next
        return dummy_head.next

707.设计链表:

题目链接：707. 设计链表 - 力扣（LeetCode）

参考资料:代码随想录 (programmercarl.com)

思路：这题较为复杂 首先我们需要选择是单链表还是双链表 我们这边选择单链表 class listnode来创造一个单链表 在MyLinkedList实现题目中的要求 

第一个是初始化mylinkedlist 

class 然后初始化dummy_head 与size即可 size是链表的长度

第二个是

int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。

我们首先要判断index是否大于等于size（即链表的长度） 因为下标是从0开始的 链表下标的最大值应该是size-1 如果index大于等于size就超出了范围 输出-1 同时下标也不能为负数 如果为负数也需要return -1

判断之后我们就需要让current{即目前的指针）指向index 首先定义current=self.dummy_head.next  让current指向除虚拟头结点的第一个链表 然后用for来让current不断后移 for i in range(index) current=current.next 这样current不断后移 一直到指向index 下面是代码实现

  def get(self, index: int) -> int:
            if index<0 or index>=self.size:
                return -1
            else:
                current=self.dummy_head.next
                for i in range(index):
                    current=current.next
            return current.val

第三个是void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。

虚拟头结点的下一个指向的就是第一个节点 所以我们只需要在虚拟头结点的后面添加元素即可

以下是代码

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

第四个是void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。

我们需要让current指向链表的最后一个元素 即用while 使current.next=null的时候停止 这时候current就指向的是最后一个元素 最后再让size+=1即可

下面是代码

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

第五个是 void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。

首先我们要检查index与size的关系 如果index大于size就return即可 等于那么该节点就会被加到链表的末尾 如果index小于0 也是return

然后我们让current=dummy_head.next 让current指向头结点 用for i in range（index） current=current.next 来指向index 然后用 current.next = ListNode(val, current.next)来添加链表 就可以实现 最后让size+=1

下面是代码

def addAtIndex(self, index: int, val: int) -> None:
            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

最后一个是void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

检查下标是否大于等于size或者小与0 如果是则return即可

让current=dummy_head.next 这时current指向的是头结点 然后用for i in range（index)

current=current.next 最后current就会指向index前一位 current.next 即指向了index 然后让current.next=current.next.next就可以删去index的节点 最后让size-=1

下面是代码

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

这个题就做完了 下面是这个题全部的代码

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

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

        def get(self, index: int) -> int:
            if index<0 or index>=self.size:
                return -1
            else:
                current=self.dummy_head.next
                for i in range(index):
                    current=current.next
            return current.val

        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:
            current=self.dummy_head.next
            while current.next:
                current=current.next
            current.next=ListNode(val)
            self.size+=1



        def addAtIndex(self, index: int, val: int) -> None:
            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:
            if index>=self.size or index<0:
                return
            current=self.dummy_head
            for i in range(index):
                current=current.next
            current.next=current.next.next
            self.size-=1


# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

206. 反转链表：206. 反转链表 - 力扣（LeetCode）

参考:代码随想录 (programmercarl.com)

思路：我们要让链表翻转 即1-2-3-4-null 为4-3-2-1-null 这里我们采用双指针法 一个指针为cur 另外一个指针为pre 我们让cur指向第一个链表 让pre指向none

用while cur 来循环 首先用temp来储存cur.next 避免cur改变后无法取到第二位 随后让cur.next=pre 即cur当前这一位指向了null 再让pre =cur 即 pre移动到了第一位 让cur=temp 让cur回到第二位 以此类推 最后return pre即可

下面是代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = 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