数据结构Day3 203.移除链表元素 707.设计链表 ● 206.反转链表

最新推荐文章于 2024-10-09 17:48:02 发布

leo2vec

最新推荐文章于 2024-10-09 17:48:02 发布

阅读量95

点赞数

文章标签：链表数据结构 java

本文链接：https://blog.csdn.net/qq_43274397/article/details/130892356

版权

本文讨论了几个涉及链表操作的编程问题，包括如何移除链表中的特定元素，设计一个链表类以支持头部插入、尾部添加、指定位置插入和删除等操作，以及如何反转链表。在解决这些问题时，作者遇到了关于链表节点判断和更新的困惑，强调了对链表结构理解的重要性。

摘要由CSDN通过智能技术生成

203.移除链表元素

这道题做过很多次了，但是这一次拿起来时候还是有点恍惚，感觉自己对于链表的代码能力还是要进行加强。一开始写错了，是因为判断值的时候的判断语句出现了错误

写成了

if cur.next == val

关于cur.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]:
        head = ListNode(next = head)
        cur = head
        while cur.next:
            if cur.next.val== val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return head.next

707.设计链表

这道题属于是不太会的类型，不太清楚从头去实现一个类，包括栈和队列，后续应当注意这方面的练习！！

对于我来说，难点在于，我不太请楚ListNode的构造和初始化，以及循环到了哪里，这个思维过程并不是特别好！可以追究的细节其实是比较多的

怎么更新节点，是一个难题！！！

class ListNode:
    def __init__(self,val = 0, next = None):
        self.next = next
        self.val = val
class MyLinkedList:
    def __init__(self):
        self.dummy_head = ListNode()
        #这个size操作有一点点没看懂，应该指的是链表的长度
        self.size = 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:
        # cur = self.dummy_head.next
        # tem = ListNode(val)
        # tem.next = cur
        # cur = tem
        # self.size += 1
        newNode = ListNode(val)
        newNode.next = self.dummy_head.next
        self.dummy_head.next = newNode
        self.size += 1
    def addAtTail(self, val: int) -> None:
        cur = self.dummy_head
        # for i in range(self.size):
        while cur.next:
            cur = cur.next
        #这时候应该循环到链表的尾部节点了
        NewNode = ListNode(val)
        cur.next = NewNode
        self.size += 1
    def addAtIndex(self, index: int, val: int) -> None:
        cur = self.dummy_head
        if index < 0 or index > self.size:
            return 
        for i in range(index):
            cur = cur.next
        NewNode = ListNode(val)
        NewNode.next = cur.next
        cur.next = NewNode
        self.size += 1
    def deleteAtIndex(self, index: int) -> None:
        cur = self.dummy_head
        if index < 0 or index >= self.size:
            return 
        # for i in range(index-1):
        for i in range(index):
            cur = cur.next
        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.反转链表

这道题主要是tem临时指针储存，相当于多了一个变量

这道题的问题出在，不应该设置虚拟节点，因为会成环导致时间以及空间的溢出

什么时候设置虚拟节点，什么时候不设置，需要详细地思考！！！

# 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]:
        # dummy_head = ListNode(0,head)

        pre = None
        cur = head
        while cur != None:
            #先用tem储存好以后的节点，避免丢失
            tem = cur.next
            cur.next = pre
            pre = cur
            cur = tem
        # head.next = None
        return pre