移除链表元素+反转链表+设计链表

移除链表元素

class ListNode:
    def __init__(self,val):
        self.val=val
        self.next=None
#输入为数组
class MyLinkedList:
    def __init__(self) -> None: #头结点
        self.head=None
    def initList(self,data):
        self.head=ListNode(data[0]) #此时的头结点就是数组中的第一个值
        r=self.head #最开始指向头结点，不动，最后返回的就是r
        p=self.head
        for i in data[1:]:
            node=ListNode(i) #先把数组中的值转换成结点型
            p.next=node
            p=p.next
        return r
    def printList(self,head):#打印链表，那么传入参数肯定得是一个链表，此时head就是就是指向整个链表的地址
        if head==None: return
        node=head
        while node!=None:
            print(node.val, end=' ')
            node=node.next
class Solution:
    def removeElements(self,head:ListNode,val:int)->ListNode:
        head_node=ListNode(0)#创建虚拟头结点
        head_node.next=head
        cur=head_node
        while cur.next!=None:
            if cur.next.val==val:
                cur.next=cur.next.next
            else:
                cur=cur.next
        return head_node.next
a = Solution()
l=MyLinkedList()
data_str=input()
data=[int(n) for n in data_str.split()]
l1=l.initList(data)
l.printList(l1)
print("\r")
num=int(input())
m=a.removeElements(l1,num)
l.printList(m)
        

反转链表

from tempfile import tempdir


class Node: #结点类型
    def __init__(self,val) -> None:
        self.val=val
        self.next=None
class Linkedlist:
    def __init__(self) -> None: #链表的头结点
        self.head=None
    def initList(self,data):
        self.head=Node(data[0])
        r=self.head
        p=self.head
        for i in data[1:]:
            node=Node(i)
            p.next=node
            p=p.next
        return r
    def printList(self,head):
        if head==None:return
        node=head
        while node!=None:
            print(node.val,end=' ')
            node=node.next
class Solution:
    def reverseList(self,head:Node)->Node:
        #反转链表 只改变结点指针的转向就行
        pre,cur=None,head
        while cur!=None:
            temp=cur.next
            cur.next=pre
            pre=cur
            cur=temp
        return pre
l=Linkedlist()
data_str=input()
data=[int(n) for n in data_str.split()]
list1=l.initList(data)
l.printList(list1)
print("\r")
a=Solution()
m=a.reverseList(list1)
l.printList(m)
        

设计链表

# 题意：

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

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

from audioop import add
from cgi import print_arguments

#单链表
class Node:
    def __init__(self,val):
        self.val=val
        self.next=None
class MyLinkedList:
    def __init__(self) : #定义头部节点和节点数
        self._head=Node(0) #虚拟头部节点
        self._count=0 #节点数
#获取结点中第index个节点的值
    def get(self,index:int)->int:
        if 0 <= index <=self._count:
            node=self._head
            for _ in range(index+1):
                node=node.next
            return node.val
        else:
            return -1
#在链表的第一个元素之前添加一个值为 val 的节点
    def addAtHead(self,val:int)->None:
        self.addAtIndex(0,val)
#在链表的最后一个元素添加值为val的节点
    def addAtTail(self,val:int)->None:
        self.addAtIndex(self._count,val)
#在链表中的第 index 个节点之前添加值为 val  的节点。
# 如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。
# 如果index小于0，则在头部插入节点。
    def addAtIndex(self,index:int,val:int)->None:
        if index<0:
            index=0
        elif index>self._count:
            return
        self._count+=1 #添加一个节点，则计数加1
        add_node=Node(val)
        prev_node,current_node=None,self._head
        for _ in range(index+1):
            prev_node,current_node=current_node,current_node.next
        else:
            prev_node.next,add_node.next=add_node,current_node
#如果索引 index 有效，则删除链表中的第 index 个节点。
    def deleteAtIndex(self,index:int)->None:
        if 0<=index<self._count:
            self._count-=1
            prev_node,current_node=None,self._head
            for _ in range(index+1):
                prev_node,current_node=current_node,current_node.next
            else:
                prev_node.next,current_node.next=current_node.next,None


#双链表
class Double_Node:
    def __init__(self,val):
        self.val=val
        self.prev=None
        self.next=None
class MydoubelLinkedList:
    def __init__(self) : #定义头部节点和节点数
        self._head,self._tail=Double_Node(0),Double_Node(0) #虚拟头部节点
        self._head.next,self._tail.prev=self._tail,self._head
        self._count=0 #节点数
#获取结点中第index个节点的值
    def _get_node(self,index:int)->None:
    #当index小于_count//2时, 使用_head查找更快, 反之_tail更快
        if index>=self._count //2:
            #使用prev往前找
            node=self._tail
            for _ in range(self._count-index):
                node=node.prev
        else:
            #使用next往后找
            node=self._head
            for _ in range(index+1):
                node=node.next
        return node

    def get(self,index:int)->int:
        if 0 <= index <=self._count:
            node=self._get_node(index)
            return node.val
        else:
            return -1

    def addAtHead(self,val:int)->None:
        self._update(self._head,self._head.next,val)

    def addAtTail(self,val:int)->None:
        self._update(self._tail.prev,self._tail,val)

    def addAtIndex(self,index:int,val:int)->None:
        if index<0:
            index=0
        elif index>self._count:
            return
        node=self._get_node(index)
        self._update(node.prev,node,val)

    def _update(self,prev:Double_Node,next:Double_Node,val:int)->None:
        self._count+=1
        node=Double_Node(val)
        prev.next,next.prev=node,node
        node.prev,node.next=prev,next

    def deleteAtIndex(self,index:int)->None:
        if 0<=index<self._count:
            node=self._get_node(index)
            self._count-=1
            node.prev.next,node.next.prev=node.next,node.prev



if __name__== "__main__":
    linkedlist = MyLinkedList()
    doubellist = MydoubelLinkedList()
    print("单链表操作：")
    linkedlist.addAtHead(1)
    linkedlist.addAtTail(3)
    linkedlist.addAtIndex(1,2)
    print(linkedlist.get(1))
    linkedlist.deleteAtIndex(1)
    print(linkedlist.get(1))
    print("双链表操作：")
    doubellist.addAtHead(1)
    doubellist.addAtTail(3)
    doubellist.addAtIndex(1,2)
    print(doubellist.get(1))
    doubellist.deleteAtIndex(1)
    print(doubellist.get(1))