单链表

 

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

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 元素

流程如下：

1. Vertex vtx = new Vertex(v) 初始化一个新的点
2. tail.next = vtx 队列尾部的后继是这个新的点
3. 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() 从链表中任意位置删除一个元素

流程如下：

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