Python链表的实现

链表

链表是一种物理上非连续，非顺序的数据结构，由若干节点(node)所组成。

单向链表的每一个节点包括两部分，一部分是存放数据的变量data,令一部分是指向下一个节点的指针next

操作

1、链表的查找 ：get(self,index)

将查找的指针定位到self.head,通过指针到下一个节点，这样循环往复，直到查找到传入的index。

如 【1，2，3】 我们需要查找到第3个节点，就是数字3。head节点为1

查找节点的时间复杂度：链表的数据只能通过顺序进行访问，最坏的时间复杂度是O(n)

2、链表的更新 : update(self,index,data)

链表的节点只需要查找到节点，将其data属性改为传入的data

3、链表插入 : insert(self,index,data)

如果不考虑插入，删除操作之间查找元素的过程，只考虑纯粹插入和删除操作，时间复杂度都是O(1)

1、尾部插入

把最后一个节点的next指向插入的新节点

2、头部插入

把新节点的next指针指向头部节点，再将新节点变为链表的头节点，self.head = node

3、中间插入

将新节点的next指针指向插入位置的节点，插入位置前置节点的next指针，指向新节点

4、删除元素 : remove(self,index)

如果不考虑插入，删除操作之间查找元素的过程，只考虑纯粹插入和删除操作，时间复杂度都是O(1)

1、尾部删除

将倒数第二个节点的next指针指向空。

2、头部删除

把链表的头节点设为原先头节点的next指针指向的节点。

3、中间删除

把要删除节点的前置节点的next指针，指向要删除元素的下一个节点即可

pre_node.next = pre_node.next.next

5、更新元素 : update(self,index,data)

如果要更新一个节点的元素，我们需要找到该节点,并更新data。

6、输出链表 : output(self)

输出链表，我们需要将赋予一个变量为链表的头节点，遍历后再将该变量赋予为他的next节点，直到遍历为空。

class Node:
    def __init__(self, data): # 初始化节点
        self.data = data
        self.next = None


class LinkedList:
    def __init__(self):
        self.size = 0
        self.head = None # 头节点
        self.last = None # 尾节点

    def get(self, index):
        if index < 0 or index >= self.size:
            raise Exception("超出链表节点范围")
        p = self.head
        for i in range(index):
            p = p.next
        return p

    def insert(self, data, index):
        if index < 0 or index > self.size:
            raise Exception("超出链表节点范围")
        node = Node(data)
        if self.size == 0:
            # 空链表
            self.head = node
            self.last = node
        elif index == 0:
            # 插入头部
            node.next = self.head
            self.head = node
        elif self.size == index:
            # 插入尾部
            self.last.next = node
            self.last = node
        else:
            # 插入中间
            prev_node = self.get(index - 1)
            node.next = prev_node.next
            prev_node.next = node
        self.size += 1

    def remove(self, index):
        if index < 0 or index >= self.size:
            raise Exception("超出链表节点范围")
        if index == 0:
            # 删除头节点
            removed_node = self.head
            self.head = self.head.next
        elif index == self.size - 1:
            # 删除尾节点
            prev_node = self.get(index - 1)
            removed_node = prev_node.next
            prev_node.next = None
            self.last = prev_node
        else:
            # 删除中间节点
            prev_node = self.get(index - 1)
            next_node = prev_node.next.next
            removed_node = prev_node.next
            prev_node.next = next_node
        self.size -= 1
        return removed_node

    def update(self,index,data):
        update_node = self.get(index)
        update_node.data = data

    def output(self):
        p = self.head
        while p is not None:
            print(p.data)
            p = p.next
        print(self.size)
    

linkedList = LinkedList()
linkedList.insert(0, 0)
linkedList.insert(1, 1)
linkedList.insert(2, 2)
linkedList.insert(3, 3)
linkedList.insert(4, 4)
linkedList.insert(5, 5)
linkedList.insert(5, 5)

linkedList.remove(3)
linkedList.output()