实现链表的完整代码

# 这个只是next来赋值变量给另外一个，有点复杂，头晕，变量太多了
class Node:
    '''
    单向链表的节点包含两部分，一部分是存放数据的变量data
    另一部分是指向下一个节点的指针next
    '''
    def __init__(self,data):
        '''
        只有头节点，next指针为空
        '''
        self.data = data
        self.next = None
# 而双向链表除了拥有data和next指针外
# 还拥有指向前置节点的prev指针   
# a = Node(1)
# print(a)
# print(a.next)
# print(a.data) 
class LinkedList:
    '''
    链表的第一个节点称为头节点
    最后一个节点称为尾节点
    尾节点的next指针指向空
    链表寻找元素，只能根据前一个节点的next指针指向后一个节点
    '''
    def __init__(self):
        self.size = 0
        self.head = None
        self.last = None

    def get(self,index): # O(n)
        if index < 0 or index >= self.size: # 链表这里为啥要等于呢
            raise Exception("超出链表节点范围!")
        p = self.head
        for i in range(index): # 链表中节点的查询操作要从头节点开始，一个一个next指针查下去
            p = p.next
        return p

    def insert(self,data,index): #O(1)
        '''
        只要执行插入操作，self.size加一
        '''
        if index < 0 or index > self.size:
            raise Exception('超出链表节点范围！')
        node = Node(data) # 这里的node具有头节点和next指针,头节点就是data数据，next为空
        if self.size == 0:
            # 空链表
            self.head = node # 新插入的节点为头节点
            self.last = node # 新插入的节点为尾节点
        elif index == 0:
            # 插入头部
            node.next = self.head # 对称交叉互换;把新节点的next指针指向原先的头节点；后面链接前面
            self.head = node # 把新节点变为链表的头节点
        elif self.size == index:
            # 插入尾部
            self.last.next = node # 最后一个节点的next指针指向新插入的节点；后面链接前面
            self.last = node # 新插入的节点等于最后一个节点
        else:
            # 插入中间
            prev_node = self.get(index-1)
            # 两个next指针相等为啥；后面链接前面，也就是data连接next
            node.next = prev_node.next # prev_node原本后面的data元素指向node的next指针
            prev_node.next = node #插入位置前置节点的next指针指向新节点 
        self.size  += 1

    def remove(self,index):# O(1)
        '''
        只要执行删除操作,self.size减1
        '''
        if index < 0 or index >= self.size:
            raise Exception('超出链表节点范围！')
        # 暂存被删除的节点，用于返回
        if index == 0:
            # 删除头节点
            remove_node = self.head
            self.head = self.head.next # 把第二个节点设置为头节点
            if self.size == 1:
                self.last == Node
        elif index == self.size - 1:
            # 删除尾节点
            prev_node = self.get(index-1)
            # remove_node = prev_node
            remove_node = self.get(index) # 这才是要指定要删除的节点
            prev_node.next = None # 倒数第二个节点指向空，也就是None
            self.last = prev_node # 最后一个节点设置为到数第二个节点
        else:
            # 删除中间节点
            prev_node = self.get(index-1)
            next_node = prev_node.next.next # 把要删除的前置节点的后2位节点数据找到
            remove_node = prev_node.next # 前置节点的后一位节点解释要删除的节点
            prev_node.next = next_node # 前置节点的后2位节点等于前置节点的next指针；也可以说前置节点的next指针指向后2位节点的数据
        self.size -= 1
        # print(remove_node)
        return remove_node # remove_node打印出来是这个<__main__.Node object at 0x000002B1C6389438>
        

    def output(self): # 难道是由于链表只能一个一个next输出;还是从头节点开始一个一个输出出来
        p = self.head
        while p is not None:
            print(p.data)
            p = p.next

linkedList = LinkedList()
linkedList.insert(3,0)    
linkedList.insert(4,0)    
linkedList.insert(9,2)
linkedList.insert(5,3)
linkedList.insert(6,1)
print(linkedList.remove(1)) # remove删除的具体值打印不出来
print('---------------')
linkedList.output()