Python实现单链表

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

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

 

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

1. 创建 Node 类

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

具体实现代码如下：

?

1 2 3 4

class Node:      def __init__(self, data):         self.data = data #表示对应的元素值         self.next = None #表示下一个链接的链点

2. 创建 Linked_List 类

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

具体实现代码如下：

?

1 2 3 4 5 6 7 8 9 10

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 的函数，功能是判断链表是否为空

具体实现代码如下：

?

1 2	def is_empty(self):         return self.Head is None #判断链表是否为空

4. 添加 insert 函数

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

流程如下：

1. Vertex vtx = new Vertex(v) 初始化一个新的点
2. tail.next = vtx 队列尾部的后继是这个新的点
3. tail = vtx 然后让队列尾部指针指向这个新的点

具体实现代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12

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() 从链表中任意位置删除一个元素

流程如下：

1. 先判断队列是否为空，为空即退出 dequeue 操作，不为空即继续后续操作
2. temp = head 设置一个 temp 指针，使它的指针指向队列头部
3. head = head.next 队列头部指针，使之指向队列头部的后继(即队列头部元素出队)
4. delete temp 删除 temp 指针

具体实现代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

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:将链表反转

具体实现代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

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。

具体实现代码如下：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70

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)