python实现单链表_Python实现单链表

链表(linked_list)是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，每个元素包含两个结点，一个是存储元素的数据域 (内存空间)，另一个是指向下一个结点地址的指针域。根据指针的指向，链表能形成不同的结构，例如单链表，双向链表，循环链表等。

链表通过将链点 i 与其邻居链点 i+1 通过指针相关联，从索引 0 到索引 N-1 对链点进行排序。

链表分为单链表和双链表两种。在接下来的内容里，我们将逐步介绍单链表的具体功能是如何实现的。

1. 创建 Node 类

创建一个 Node 的类，作为基础数据结构：链点，并初始化对应的内参。

具体实现代码如下：

class Node:

def __init__(self, data):

self.data = data #表示对应的元素值

self.next = None #表示下一个链接的链点

2. 创建 Linked_List 类

创建一个 Linked_List 的类，并初始化对应的内参。

具体实现代码如下：

class Linked_List:

def __init__(self):

self.head = None #表示链表的头部元素

def initlist(self,data_list): #链表初始化函数

self.head=Node(data_list[0]) #创建头结点

temp=self.head

for i in data_list[1:]: #逐个为 data 内的数据创建结点, 建立链表

node=Node(i)

temp.next=node

temp=temp.next

3. 添加 is_empty 函数

添加一个 is_empty 的函数，功能是判断链表是否为空

具体实现代码如下：

def is_empty(self):

return self.Head is None #判断链表是否为空

4. 添加 insert 函数

insert(item) 往链表中任意位置添加一个 item 元素

流程如下：

Vertex vtx = new Vertex(v) 初始化一个新的点

tail.next = vtx 队列尾部的后继是这个新的点

tail = vtx 然后让队列尾部指针指向这个新的点

具体实现代码如下：

def insert(self,key,value): #链表插入数据函数

if key<0 or key>self.get_length()-1:

print("insert error")

temp=self.head

i=0

while i<=key: #遍历找到索引值为 key 的结点后, 在其后面插入结点

pre=temp

temp=temp.next

i=i+1

node=Node(value)

pre.next=node

node.next=temp

5. 添加 remove 函数

remove() 从链表中任意位置删除一个元素

流程如下：

先判断队列是否为空，为空即退出 dequeue 操作，不为空即继续后续操作

temp = head 设置一个 temp 指针，使它的指针指向队列头部

head = head.next 队列头部指针，使之指向队列头部的后继(即队列头部元素出队)

delete temp 删除 temp 指针

具体实现代码如下：

def remove(self,key): #链表删除数据函数

if key<0 or key>self.get_length()-1:

print("insert error")

i=0

temp=self.head

while temp !=None: #遍历找到索引值为 key 的结点

pre=temp

temp=temp.next

i=i+1

if i==key:

pre.next=temp.next

temp=None

return True

pre.next=None

6. 添加其他函数

get_length:获取链表的长度

print_list:遍历链表，并将元素依次打印出来

reverse:将链表反转

具体实现代码如下：

def get_length(self): #获取链表的长度

temp=self.head #临时变量指向队列头部

length=0 #计算链表的长度变量

while temp!=None:

length=length+1

temp=temp.next

return length #返回链表的长度

def print_list(self): #遍历链表，并将元素依次打印出来

print("linked_list:")

temp = self.head #临时变量指向队列头部

while temp is not None:

print(temp.data)

temp = temp.next

def reverse(self): #将链表反转

prev = None

current = self.head

while current:

next_node = current.next

current.next = prev

prev = current

current = next_node

self.head = prev

基于链表的基本功能介绍，我们给出链表的完整代码

在/home/shiyanlou/下新建一个文件linked_list.py。

具体实现代码如下：

class Node:

def __init__(self, data):

self.data = data

self.next = None

class Linked_List:

def __init__(self):

self.head = None

def initlist(self,data_list): #链表初始化函数

self.head=Node(data_list[0]) #创建头结点

temp=self.head

for i in data_list[1:]: #逐个为 data 内的数据创建结点, 建立链表

node=Node(i)

temp.next=node

temp=temp.next

def is_empty(self): #判断链表是否为空

if self.head.next==None:

print("Linked_list is empty")

return True

else:

return False

def get_length(self): #获取链表的长度

temp=self.head #临时变量指向队列头部

length=0 #计算链表的长度变量

while temp!=None:

length=length+1

temp=temp.next

return length #返回链表的长度

def insert(self,key,value): #链表插入数据函数

if key<0 or key>self.get_length()-1:

print("insert error")

temp=self.head

i=0

while i<=key: #遍历找到索引值为 key 的结点后, 在其后面插入结点

pre=temp

temp=temp.next

i=i+1

node=Node(value)

pre.next=node

node.next=temp

def print_list(self): #遍历链表，并将元素依次打印出来

print("linked_list:")

temp=self.head

new_list=[]

while temp is not None:

new_list.append(temp.data)

temp=temp.next

print(new_list)

def remove(self,key): #链表删除数据函数

if key<0 or key>self.get_length()-1:

print("insert error")

i=0

temp=self.head

while temp !=None: #遍历找到索引值为 key 的结点

pre=temp

temp=temp.next

i=i+1

if i==key:

pre.next=temp.next

temp=None

return True

pre.next=None

def reverse(self): #将链表反转

prev = None

current = self.head

while current:

next_node = current.next

current.next = prev

prev = current

current = next_node

self.head = prev

复杂度分析

链表属于常见的一种线性结构，对于插入和移除而言，时间复杂度都为 O(1)

但是对于搜索操作而言，不管从链表的头部还是尾部，都需要遍历 O(n)，所以最好复杂度为 O(1)，最坏的情况就是从头部遍历到尾部才搜索出对应的元素，所以最坏复杂度为 O(n)，平均复杂度为 O(n)。

归纳如下：

最好复杂度为 O(1)

最坏复杂度为 O(n)

平均复杂度为 O(n)