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

本文链接：https://blog.csdn.net/muye214/article/details/136288952

讲解

链表的定义

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

题目及题解

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

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  #不能返回head节点，可能已经被删了

题目链接：707. 设计链表

看到题目的时候知道大概思路，但是不知道怎么写，看完视频讲解之后又看了文章讲解，主要学习了怎么用index、怎么记录链表长度

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

class MyLinkedList:

    def __init__(self):
        self.dummyhead = LinkNode()
        self.size = 0

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

    def addAtHead(self, val: int) -> None:
        newnode = LinkNode(val,self.dummyhead.next)
        cur = self.dummyhead
        cur.next = newnode
        self.size += 1

    def addAtTail(self, val: int) -> None:
        newnode = LinkNode(val)
        cur = self.dummyhead
        while (cur.next != None):
            cur = cur.next
        cur.next = newnode
        self.size += 1

    def addAtIndex(self, index: int, val: int) -> None:
        if index>=0 and index<= self.size:
            newnode = LinkNode(val)
            cur = self.dummyhead
            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 and index< self.size:
            cur = self.dummyhead
            while(index):
                cur = cur.next
                index -= 1
            cur.next = cur.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. 反转链表

自己写的：

一开始没有考虑到空值、单节点的情况，运行多次修改出来的，有点复杂但是运行通过了……

# 双指针
# 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]:    
            if type(head) == ListNode:
                newhead = head.next
                head.next = None
                if(newhead != None):
                    while(newhead.next != None):
                        cur = newhead.next
                        newhead.next = head
                        head = newhead
                        newhead = cur
                    newhead.next = head
                    head = newhead
            return head

看视频讲解之后写的：

# 双指针
# 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):
                tmp = cur.next
                cur.next = pre
                pre = cur
                cur = tmp
            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: ListNode) -> ListNode:    
        return self.reverse(head,None)
    def reverse(self,cur: ListNode,pre: ListNode) -> ListNode:
        if cur:
            temp = cur.next
            cur.next = pre
            return self.reverse(temp,cur)
        return pre