【代码随想录】【链表】补day3:移除链表元素、设计链表、反转链表

移除链表元素

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

设计一个链表

在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。 addAtIndex(index,val)：在链表中的第
index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index
大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。 deleteAtIndex(index)：如果索引 index
有效，则删除链表中的第 index 个节点。
https://www.programmercarl.com/

反转链表

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

首先要定义链表类

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

思路：1.获取第n个节点的值：首先确定要怎么循环才能遍历到n的值，什么时候停止循环，在索引有效的情况下，每一次循环当前指针向后移动一位

思路：2.可以在solution类里面定义一个从数组创建链表的方法，再定义一个print链表的方法，这样输入输出都比较简洁

class solution:

    ## 设计链表过程中，除了链表的数据域和指针域，还需要链表大小这个属性
    def __init__(self):
        self.dummynode=ListNode() # 为所有的方法构建一个虚拟头结点
        self.size=0


    ## 从列表创建链表并获取链表大小
    def createLink(self,nums:List[int])->ListNode:
        head=ListNode(val=nums[0])
        self.dummynode.next=head
        self.size=1
        cur=head
        for i in range(1,len(nums)):
            cur.next=ListNode(val=nums[i])
            cur=cur.next
            self.size+=1
        return head

    def printNode(self,head):
        if head is None:
            return
        cur = head
        while cur:
            print(cur.val, end="->")
            cur = cur.next
        print('null')

1.移除链表元素

 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

2.获取索引为index的节点的值

 def getindex(self,head:Optional[ListNode],target:int)->int:
        cur=head # 指针从头结点开始
        # 当前节点不是最后一个节点，链表不为空
        if target<0 or target>self.size:
            return -1
        else:
            while(target-1):
                cur=cur.next
                target-=1
            return cur.val

3.在头结点插入

def addAtHead(self,head:Optional[ListNode],val:int)->ListNode:
    cur=self.dummynode # 指针从虚拟头结点开始
    a=ListNode(val=val,next=head)
    cur.next=a
    self.size+=1
    return cur.next

4.在尾结点插入

   def addAtTail(self,head:Optional[ListNode],val:int)->ListNode:
        cur=self.dummynode #
        while(cur.next):
            cur=cur.next

        cur.next=ListNode(val=val,next=cur.next)
        self.size+=1
        return head

5.在index索引处插入

   def addAtindex(self,head:Optional[ListNode],target:int,val:int)->ListNode:
        cur=self.dummynode # 算是第0个节点
        if target<0:
            self.addAtHead(head,target)
        elif target > self.size:
            self.addAtTail(head,target)
        else:
            while(target-1):
                cur=cur.next
                target-=1

            cur.next=ListNode(val=val,next=cur.next)
            return head

6.删除index处的节点

  def deleteAtindex(self,head:Optional[ListNode],target:int)->ListNode:
        cur=self.dummynode # 算是第0个节点
        if target<0:
            return -1
        elif target > self.size:
            return -1
        else:
            while(target-1):
                cur.next=cur.next.next
                target-=1
            self.size-=1
            return head

7.反转链表

  # 反转链表的方法
    def reverseLink(self,head:Optional[ListNode])->Optional[ListNode]:
        # 反转：即当前节点的next的next指向当前节点，循环到当前节点的next为null的时候
        pre=None
        cur =head
        # 改变next的next后，原节点之间的链接会断开，所以需要提前保存next节点
        while (cur):
            temp=cur.next
            cur.next=pre
            pre=cur
            cur=temp
        return pre

函数调用

if __name__ == "__main__":
    nums=[3,3,1,2,5,3,5,6,3,3,7,3]
    target=4  # 位置
    val =3   # 数值
    s = solution()
    l=s.createLink(nums)
    # 构建好的链表
    s.printNode(l)
    # l1 = s.getindex(l, target)
    # print(l1)
    #
    # l2=s.addAtHead(l, val)
    # l3=s.addAtTail(l,val)
    # l4=s.addAtindex(l,target,val)
    l5=s.reverseLink(l)

    # s.printNode(l3)
    # s.printNode(l2)
    # s.printNode(l4)
    s.printNode(l5)

• 用时：3.5小时