标签：+=   while   def   linked   __init__   范围   mod   表头   exce   

链表

链表是一种单线联络的形式

单向链表的结构： data|next ---> data|next ---> data|next ---> data|next ---> .... ---> NULL

既然有单向列表，如果我快速地找到前面的节点，怎么办？

双向链表

NULL <--- prev|data|next ---> prev|data|next ---> prev|data|next ---> .... ---> NULL

节点

class Node():
    def __init__(self,data):
        self.data = data 
        self.next = None

新建一个节点

node = Node(data)

新建的节点是干净的，只有数据，指针为空

每一个节点分两部分：一部分放数据，另一部分放指针，这个指针初始为空，未来将指向下一个节点

头结点和尾节点

我们定义链表的第一个节点是头节点，链表的最后一个是尾节点。

特别的，尾节点的next指针指向NULL

链表的存储

链表在内存的存储是：随机存储，不同于数组是顺序存储.

链表的每一个元素见缝插针的分布在内存中不同位置，使用next指针进行关联。有效的利用了零散的空间。

链表的操作

查找节点

只能从第一个节点开始逐一查找

更新节点

这里的更新节点，指的是更新节电里的数据，和数组一样，直接重新赋值即可

插入节点

class LinkedList():
    def __init__(self):
        self.head = None
        self.last = None
        self.size = 0

共同的：不管是哪种插入，链表长度都要加1

尾部插入

1. 新建新节点

2. 链表尾节点next 指向 新节点

3. 链表尾节点更新为新节点

头部插入

1. 新建新节点

2. 新节点next 指向 头结点

3. 头结点更新为新节点

中间插入

1. 新建新节点

2. 找到前节点prev_node

3. 新节点指向 prev_node.next.next

4. 前节点next 指向 新节点

删除节点

共同的：无论是哪种删除都要记得 self.size -= 1;最好能够返回删除的节点

尾部删除

1. 找到倒数第二个节点 prev_node = self.get(index-1)

2. prev_node.next = None

3. 删除的节点 = 尾节点prev_node.next

头部删除

1. 删除的节点 = 头节点

2. 直接更新头节点为第二个节点即可

中间删除

1. 找到删除位置的前一个节点 prev_node

2. 找到删除位置的后一个节点 next_node

3. 删除的节点 = prev.node.next

4. prev_node.next = next_node

窍门：先找删除位置前面的节点，因为单向链表是可以顺着从前面往后找的，但是逆着不行，找到删除位置前一个节点，也就意味着找到后面的所有节点

完整代码

class Node():
    def __init__(self,data):
        self.data = data
        self.next = None
?
class LinkedList():
    # 初始化成员变量，head、last代表头节点和尾节点；size初始化为0
    def __init__(self):
        self.head = None
        self.last = None
        self.size = 0
    # 获取index处的元素
    def get(self,index):
        if index < 0 and index > self.size:# 先判断是不是在索引范围之内，index是否有效
            raise Exception("index超出范围")
        else:# 这个else可有可无，因为如果上面报错的话，根本不会向后面执行
            p = self.head# 链表的查找，只能从第一个开始
            for i in range(index):# 从0到index-1，共计执行index次，链表的索引也是从0开始，比如找到索引为9，需要迭代9次
                p = p.next
            return p
?
    def insert(self,data,index):
        if index < 0 and index > self.size:
            raise Exception("超出链表范围")
        node = Node(data)# 新建节点
        if self.size == 0:# 插入的特殊情况，如果链表为空链表，那么特殊的是头结点和尾节点都是新node，\
            self.head = node# 也就是不只要更新头node或者尾node，需要全部更新为新node
            self.last = node
        elif index == 0:# 在开始插入，新节点指向 头结点，更新头节点
            node.next = self.head
            self.head = node
        elif index == self.size:# 在末尾插入，现有列表最大索引 = self.size-1，所以index=self.size就是链表末尾
            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 and index > self.size:
            raise Exception("超出链表范围")
        if index == 0:
            remove_node = self.head
            self.head = remove_node.next
        elif index == self.size-1:
            prev_node = self.get(index-1)
            remove_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
            remove_node = prev_node.next
            prev_node.next = next_node
?
        self.size -= 1
        return remove_node
?
    def output(self):
        p = self.head
        while p is not None:
            print(p.data,end=" ")
            p = p.next
?
linkedList = LinkedList()
linkedList.insert(3,0)
linkedList.insert(2,1)
linkedList.insert(3,2)
linkedList.insert(2,3)
linkedList.insert(1,4)
linkedList.insert(4,5)
linkedList.insert(5,6)
linkedList.insert(9,7)
linkedList.output()
print(‘\n‘)
linkedList.remove(0)
linkedList.output()

链表 Python

标签：+=   while   def   linked   __init__   范围   mod   表头   exce   

原文地址：https://www.cnblogs.com/wb-Hopen/p/12951291.html