代码随想录算法训练营第3天｜203. 移除链表元素, 707. 设计链表，206. 反转链表

最新推荐文章于 2024-07-24 23:49:50 发布

m0_73129924

最新推荐文章于 2024-07-24 23:49:50 发布

阅读量98

点赞数

文章标签： python leetcode

本文链接：https://blog.csdn.net/m0_73129924/article/details/128676083

版权

203. 移除链表元素

解法1：迭代（虚拟头节点）

（1）当下一个链表的头节点值等于要移除的值时，当前的头节点直接把指针指向下下个头节点

（2）当下一个链表的头节点值不等于要移除的值时，当前节点直接跳到下一个头节点

class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        if not head:
            return head
        res = ListNode(-1,head)
        node = res       
        while node.next:
            if node.next.val == val:
                node.next = node.next.next
            else:
                node = node.next
        return res.next

解法2：递归

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

707. 设计链表(单链表)

class ListNode:

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


class MyLinkedList:

    def __init__(self):
        self.size = 0
        self.head = ListNode(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:
        new_node = ListNode(val)
        new_node.next = self.head.next
        self.head.next = new_node
        self.size += 1

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


    def addAtIndex(self, index: int, val: int) -> None:
        if index > self.size:
            return
        index = max(0, index)
        self.size += 1
        pred = self.head
        for _ in range(index):
            pred = pred.next
        to_add = ListNode(val)
        to_add.next = pred.next
        pred.next = to_add

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

206. 反转链表

解法1：双指针(pre,cur)

细节注意：（1）终止条件 cur = None;

(2) 先移动pre, 再移动cur;

(3) return 新链表头节点在pre上.

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

            pre = cur
            cur = temp
        return pre

解法2：递归（跟着双指针的方式写）

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