算法训练营day3|链表1

最新推荐文章于 2024-08-08 15:12:59 发布

易亿

最新推荐文章于 2024-08-08 15:12:59 发布

阅读量750

点赞数 14

文章标签：算法链表数据结构 leetcode

本文链接：https://blog.csdn.net/dyy3642/article/details/139569062

版权

LeetCode 203.移除链表元素

文档讲解：代码随想录

视频讲解：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

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

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

1、思路

链表操作的两种方式：

直接使用原来的链表来进行删除操作

需要考虑两种情况：删除头节点、删除非头节点

设置一个虚拟头节点再进行删除操作

原链表所有节点都按照统计方式进行删除。

时间复杂度：O(n)

空间复杂度：O(1)

2、代码

class Solution:
    def removeElements(self,head:Optional[ListNode],val:int) -> Optional[ListNode]
        #创建虚拟头部节点以简化删除过程
        dummy_head=ListNode(next=head)
        
        #遍历列表并删除值为val的节点
        current=dummy_head
        while current.next:
            if current.next.val==val:
                current.next=current.next.next
            else:
                current=current.next
        return dummy_head.next

LeetCode 707.设计链表

文档讲解：代码随想录

视频讲解：帮你把链表操作学个通透！LeetCode：707.设计链表_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

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

单链表中的节点应该具备两个属性：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 的节点。

示例：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

1、思路

设置一个虚拟头节点再进行操作。

时间复杂度：涉及index的相关振作为O(index),其余为O(1)

空间复杂度：O(n)

2、代码

#版本一：单链表法
#定义链表节点的结构体
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

    #获取第index个节点的值，如果index是非法数值则直接返回-1
    #注意index是从0开始的，第0个节点就是头节点
    def get(self,index:int)->int:
        if index < 0 or index >= self.size:
            return -1

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

    #在第index节点前插入一个新节点
    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

    #删除第index个节点，如果index大于或等于链表的长度，则直接返回
    def deleteAtIndex(self,index:int) -> None:
        if index < 0 or index >= self.size:
            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, prev=None, next=None):
        self.val = val
        self.prev = prev
        self.next = next

class MyLinkedList:
    def __init__(self):
        self.head = None
        self.tail = None
        self.size = 0

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

    def addAtHead(self, val: int) -> None:
        new_node = ListNode(val, None, self.head)
        if self.head:
            self.head.prev = new_node
        else:
            self.tail = new_node
        self.head = new_node
        self.size += 1

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

    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        
        if index == 0:
            self.addAtHead(val)
        elif index == self.size:
            self.addAtTail(val)
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index - 1):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index):
                    current = current.prev
            new_node = ListNode(val, current, current.next)
            current.next.prev = new_node
            current.next = new_node
            self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        
        if index == 0:
            self.head = self.head.next
            if self.head:
                self.head.prev = None
            else:
                self.tail = None
        elif index == self.size - 1:
            self.tail = self.tail.prev
            if self.tail:
                self.tail.next = None
            else:
                self.head = None
        else:
            if index < self.size // 2:
                current = self.head
                for i in range(index):
                    current = current.next
            else:
                current = self.tail
                for i in range(self.size - index - 1):
                    current = current.prev
            current.prev.next = current.next
            current.next.prev = current.prev
        self.size -= 1

LeetCode 206.反转链表

文档讲解：代码随想录

视频讲解：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili

题目链接：. - 力扣（LeetCode）

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

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

1、思路

如果再定义一个新的链表，实现链表元素的反转，其实这是对内存空间的浪费。

其实只需要改变链表的next指针的指向，直接将链表反转

1.1 双指针法

定义一个cur指针，指向头节点，再定义一个pre指针，初始化为null
temp=cur -> next ,保存一下cur的下一个节点
反转节点： cur -> next = pre
循环更新： pre=cur , cur = temp
最后cur指针指向了null，循环结束，链表反转完毕。ruturn pre,pre指针指向了新的头节点。

时间复杂度：O(n)

空间复杂度：O(1)

1.2 递归法

确定递归退出的条件，cur=null 时退出递归
外层：reverse(cur,pre)

递归终止条件；

temp = cur -> next ,保存当前节点下一个节点

反转节点：cur -> next = pre

内层：reverse (temp,cur);

时间复杂度：O(n)

空间复杂度：O(1)

2、代码

2.1 双指针法

# 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:
        cur = head   
        pre = None
        while cur:
            temp = cur.next # 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur.next = pre #反转
            #更新pre、cur指针
            pre = cur
            cur = temp
        return pre

2.2 递归法

# 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 == None:
            return pre
        temp = cur.next
        cur.next = pre
        return self.reverse(temp, cur)