链表简介—Python实现基本操作

~卷心菜~

已于 2022-02-10 20:20:16 修改

阅读量2.7k

点赞数 5

分类专栏：数据结构与算法--Python 文章标签：链表 python 数据结构

于 2022-02-09 20:30:32 首次发布

本文链接：https://blog.csdn.net/liu888663/article/details/122838798

版权

数据结构与算法--Python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

线性表的定义：一些元素的序列，维持元素之间的一种线性关系。实现线性表的基本需要是：

能够找到表中的首元素（无论直接或者间接）
从表里的任一元素出发，可以找到它之后的下一个元素

把表元素保存在连续的存储区里（顺序表），可以满足这两个需求，其中元素间的顺序关联是隐含的。显然，对象之间的链接也可以看作是一种顺序关联，基于它也可以实现线性表。

实现线性表的另一种常用方式就是基于链接结构，用链接关系显式表示元素之间的顺序关系。基于链接技术实现的线性表称为链接表或链表。

链表实现的基本想法：

把表中的元素分别存储在一批独立的存储块（表的结点）里
保证从组成表结构中的任一个结点可找到与其相关的下一个结点
在前一结点里用链接的方式显式地记录与下一个结点之间的关联

单链表

单链表的结点是一个二元组，其表元素域elem保存着作为表元素的数据项，链接域next里保存同一个表里的下一个结点的标识。

为了掌握一个表，只需要用一个变量保存着这个表的首结点的引用（标识或称为链接）。总结一下：

一个单链表由一些具体的表结点构成
每个结点是一个对象，有自己的标识（该结点的链接）
结点之间通过结点链接建立起单向的顺序联系

# 一个简单的表结点类
class LNode:
    def __init__(self, elem, next_=None):
        self.elem = elem
        self.next = next_

链表操作的复杂度

创建空表：O(1)
删除表：O(1)
判断空表：O(1)
加入、删除元素：
- 首端加入、删除：O(1)
- 尾端加入、删除：O(n)
- 定位加入、删除：O(n)
扫描、定位或遍历操作：O(n)

单链表类的实现

class LinkedListUnderflow(ValueError):
    pass

class LList:
    def __init__(self):
        self._head = None

    def is_empty(self):
        return self._head is None

    # 前端插入
    def prepend(self, elem):
        self._head = LNode(elem, self._head)

    # 前端删除
    def pop(self):
        if self._head is None: # 无结点，引发异常
            raise LinkedListUnderflow("in pop")
        e = self._head.elem
        self._head = self._head.next
        return e

    # 后端插入
    def append(self, elem):
        if self._head is None:
            self._head = LNode(elem)
            return
        p = self._head
        while p.next is not None:
            p = p.next
        p.next = LNode(elem)

    # 后端删除
    def pop_last(self):
        if self._head is None:
            raise LinkedListUnderflow("in pop_last")
        p = self._head
        if p.next is None:
            e = p.elem
            self._head = None
            return e
        while p.next.next is not None:
            p = p.next
        e = p.next.elem
        p.next = None
        return e

    # 链表反转
    def reverse(self):
        p = None
        while self._head is not None:
            q = self._head
            self._head = q.next # 摘下原来的首结点
            q.next = p
            p = q               # 将刚摘下的结点加入p引用的结点序列
        self._head = p          # 反转后的结点序列已经做好，重置表头链接

    def print_all(self):
        p = self._head
        while p is not None:
            print(p.elem, end='')
            if p.next is not None:
                print(', ', end='')
            p = p.next
        print('')
# 使用链表
mlist1 = LList()
for i in range(10):
    mlist1.prepend(i)
for i in range(11, 20):
    mlist1.append(i)
mlist1.print_all()

链表的变形和操作

    即使同为单链表，也存在多种不同的设计，完全可以根据需要和认识修改已有的设计。前面单链表实现有一个缺点：尾端加入元素操作的效率低，因为这时只能从表头开始查找，直到表的最后一个结点才能链接新的结点。我们可以对表对象增加一个表尾结点引用域，这样只需要常量时间就能找到尾结点，在表尾加入新结点的操作就能做到O(1)

class LList1(LList):
    def __init__(self):
        LList.__init__(self)
        self._rear = None

    def prepend(self, elem):
        if self._head is None:  # 空表
            self._head = LNode(elem, self._head)
            self._rear = self._head
        else:
            self._head = LNode(elem, self._head)

    def append(self, elem):
        if self._head is None:
            self._head = LNode(elem, self._head)
            self._rear = self._head
        else:
            self._rear.next = LNode(elem)
            self._rear = self._rear.next

    def pop_last(self):
        if self._head is None:
            raise LinkedListUnderflow("in pop_last")
        p = self._head
        if p.next is None:
            e = p.elem
            self._head = None
            return e
        while p.next.next is not None:
            p = p.next
        e = p.next.elem
        p.next = None
        self._rear = p
        return e

选循环单链表

单链表的另一常见变形是循环单链表（环链表），其中最后一个结点的next域不用None，而是指向表的第一个结点。这种表对象只需一个数据域_rear，它在逻辑上始终引用着表的尾结点。

class LCList:
    def __init__(self):
        self._rear = None

    def is_empty(self):
        return self._rear is None

    # 前端插入
    def prepend(self, elem):
        p = LNode(elem)
        if self._rear is None:
            p.next = p  # 建立一个结点的环
            self._rear = p
        else:
            p.next = self._rear.next
            self._rear.next = p
            
    # 后端插入
    def append(self, elem):
        self.prepend(elem)
        self._rear = self._rear.next
    
    def pop(self):
        if self._rear is None:
            raise LinkedListUnderflow("in pop of CLList")
        p = self._rear.next
        if self._rear is p:
            self._rear = None
        else:
            self._rear.next = p.next
        return p.elem

    def print_all(self):
        if self.is_empty():
            return
        p = self._rear.next
        while True:
            print(p.elem)
            if p is self._rear:
                break
            p = p.next

双链表

单链表只有一个方向的链接，只能做一个方向的扫描和逐步操作。即使增加了尾结点引用，也只能支持O(1)时间的首端元素加入/删除和尾端加入。如果希望两端插入和删除操作能高效完成，就必须修改结点的基本设计，加入另一个方向的链接。这就得到了双向链表。这样需要每个结点都需要增加一个链接域，增加的空间开销与结点数成正比，是O(n)。如果每个表结点里的数据规模比较大，新增加的开销可能就显得不太重要了。

class DLNode(LNode):
    def __init__(self, elem, prev=None, next_=None):
        LNode.__init__(self, elem, next_)
        self.prev = prev


class DLLIst(LList1):
    def __init__(self):
        LList1.__init__(self)

    def prepend(self, elem):
        p = DLNode(elem, None, self._head)
        if self._head is None:  # 空表
            self._rear = p
        else:
            p.next.prev = p  # 非空表，设置prev引用
        self._head = p

    def append(self, elem):
        p = DLNode(elem, self._rear, None)
        if self._head is None:  # 空表
            self._head = p
        else:
            p.prev.next = p  # 非空表，设置next引用
        self._rear = p

    def pop(self):
        if self._head is None:
            raise LinkedListUnderflow('in pop of DLList')
        e = self._head.elem
        self._head = self._head.next
        if self._head is not None:  # _head空时不需要做任何事
            self._head.prev = None
        return e

    def pop_last(self):
        if self._head is None:
            raise LinkedListUnderflow('in pop_last of DLList')
        e = self._rear.elem
        self._rear = self._rear.prev
        if self._rear is None:
            self._head = None  # 设置_head保证is_empty正确工作
        else:
            self._rear.next = None
        return e

表的应用--示例：Josephus问题

Josephus问题是数据结构的一个常见实例：假设有n个人围坐一圈，现在要求从第k个人开始报数，报到第m个数的人退出。然后从下一个人开始继续报数并按同样的规则退出，直至所有人退出。要求按顺序输出各出列人的编号。

解法一：基于list和固定大小的“数组概念”
把list看作元素个数固定的对象，只修改元素的值，不改变表的结构。相当于摆了一圈n把椅子，人可以走但椅子在那里且位置不变。下面这个方法是给每个人赋予一个编号，没有的情况下用0表示，各list的元素记录这些编号，算法梗概：
        初始：建立一个包含n个人（的编号）的表；找到第k个人，从那里开始
        处理过程中采用把相应表元素修改为0的方式表示已出列，反复做：数m个（尚在坐的）人，遇到表的末端就转回下标0继续；把表示第m个人的表元素修改为0
        n个人出列即结束
```
def josephus_A(n, k, m):
    people = list(range(1, n+1))
    i = k - 1
    for num in range(n):
        count = 0
        while count < m:
            if people[i] > 0:
                count += 1
            if count == m:
                print(people[i], end="")
                people[i] = 0
            i = (i + 1) % n
        if num < n - 1:
            print(", ", end="")
        else:
            print("")
    return
josephus_A(10, 2, 7)  

# output: 8, 5, 3, 2, 4, 7, 1, 6, 9, 10
# 算法时间复杂度：O(n2 X logn)
```

解法二：基于顺序表的解
把保存人员编号的list按表的方式处理，一旦确定了应该退出的人，就将表示其编号的表元素从表中删除。

def josephus_L(n, k, m):
    people = list(range(1, n + 1))
    num, i = n, k - 1
    for num in range(n, 0, -1):
        i = (i + m - 1) % num
        print(people.pop(i), end=", " if num > 1 else "\n")
    return
josephus_L(10, 2, 7)  

# output: 8, 5, 3, 2, 4, 7, 1, 6, 9, 10
# 算法时间复杂度：O(n2)

解法三：基于循环单链表的解
循环单链表可以很直观地表示围坐一圈的人，顺序数人头可以自然反应为在循环表中沿着next链扫描，一人退出可以用删除相应结点的操作模拟。这个算法应该分为两个阶段：
建立包含指定个数（和内容）的结点的循环单链表
循环计数，找到并删除应该退出的结点

class Josephus(LCList):
    def turn(self, m):
        for i in range(m):
            self._rear = self._rear.next

    def __init__(self, n, k, m):
        LCList.__init__(self)
        for i in range(n):
            self.append(i + 1)
        self.turn(k - 1)
        while not self.is_empty():
            self.turn(m - 1)
            print(self.pop(), end="\n" if self.is_empty() else ", ")
Josephus(10, 2, 7)  

# output: 8, 5, 3, 2, 4, 7, 1, 6, 9, 10
# 算法复杂度： O(m x n)

~卷心菜~

关注

5
点赞
踩
10

收藏

觉得还不错? 一键收藏
打赏
0
评论
链表简介—Python实现基本操作

目录单链表链表操作的复杂度单链表类的实现链表的变形和操作选循环单链表双链表线性表的定义：一些元素的序列，维持元素之间的一种线性关系。实现线性表的基本需要是：能够找到表中的首元素（无论直接或者间接）从表里的任一元素出发，可以找到它之后的下一个元素把表元素保存在连续的存储区里（顺序表），可以满足这两个需求，其中元素间的顺序关联是隐含的。显然，对象之间的链接也可以看作是一种顺序关联，基于它也可以实现线性表。实现线性表的另一种常用方式就是基于链接结构，用链接关系显式表示元素
复制链接

扫一扫