Python与数据结构[0] -> 链表/LinkedList[1] -> 双链表与循环双链表的 Python 实现
双链表 / Doubly Linked List
目录
1 双链表
双链表和单链表的不同之处在于，双链表需要多增加一个域（C语言），即在Python中需要多增加一个属性，用于存储指向前一个结点的信息。
Doubly linked list:
node_1 <---> node_2 <---> node_3
完整代码
from linked_list import LinkedList, test class NodeDual:
def __init__(self, val=None, nxt=None, pre=None):
self.value = val
self.next = nxt
self.prev = pre def __str__(self):
return '<NodeDual, prev=%s, value=%s, next=%s>' % (self.prev.value if self.prev else self.prev,
self.value,
self.next.value if self.next else self.next) class DoublyLinkedList(LinkedList):
"""
Doubly linked list:
node_1 <---> node_2 <---> node_3
"""
def __str__(self):
def _traversal(self):
node = self.header
while node and node.next:
yield node
node = node.next
yield node
return '<->\n'.join(map(lambda x: str(x), _traversal(self))) def init(self, iterable=()):
if not iterable:
return
self.header = NodeDual(iterable[0]) # header value
pre = None
node = self.header
for i in iterable[1:]: # add all node
node.prev = pre
node.next = NodeDual(i)
pre = node
node = node.next
node.prev = pre def find_previous(self, item):
return self.find(item).prev def delete(self, item):
pre = self.find_previous(item)
if pre:
pre.next = pre.next.next
pre.next.prev = pre def insert(self, item, index):
if abs(index) > self.length:
return
if index < 0:
self.insert(item, self.length+index+1)
return
elif index == 0:
self.insert(self.header.value, 1)
self.header.value = item
return
node = self.header
i = 0
while i < index-1:
node = node.next
i += 1
n = node.next
node.next = NodeDual(item, nxt=n, pre=node)
if n:
n.prev = node.next if __name__ == '__main__':
test(DoublyLinkedList())
分段解释
双链表可以的基本特性与单链表相同，因此可以继承单链表。首先导入前面写好的单链表类和测试函数。
from linked_list import LinkedList, test
然后定义一个双向结点，包含前后两个属性，用于存放前后结点的信息。同时重定义__str__方法，在显示结点时显示该结点的前后结点及自身值，从而方便查看。
class NodeDual:
def __init__(self, val=None, nxt=None, pre=None):
self.value = val
self.next = nxt
self.prev = pre def __str__(self):
return '<NodeDual, prev=%s, value=%s, next=%s>' % (self.prev.value if self.prev else self.prev,
self.value,
self.next.value if self.next else self.next)
定义双链表类，基类为单链表，构造函数可以使用单链表的构造函数。
class DoublyLinkedList(LinkedList):
"""
Doubly linked list:
node_1 <---> node_2 <---> node_3
"""
def __str__(self):
def _traversal(self):
node = self.header
while node and node.next:
yield node
node = node.next
yield node
return '<->\n'.join(map(lambda x: str(x), _traversal(self)))
init方法，与单链表不同的地方在于，添加结点时需要同时修改结点的前后属性（引用指针）。
def init(self, iterable=()):
if not iterable:
return
self.header = NodeDual(iterable[0]) # header value
pre = None
node = self.header
for i in iterable[1:]: # add all node
node.prev = pre
node.next = NodeDual(i)
pre = node
node = node.next
node.prev = pre
find_previous方法，查找前一个结点的方法将变得很简单，只需要找到需要找的结点后，通过结点获取前一个结点即可。
def find_previous(self, item):
return self.find(item).prev
删除和插入类似于单链表的思路，只不过需要多处理一个前驱结点引用。
def delete(self, item):
pre = self.find_previous(item)
if pre:
pre.next = pre.next.next
pre.next.prev = pre def insert(self, item, index):
if abs(index) > self.length:
return
if index < 0:
self.insert(item, self.length+index+1)
return
elif index == 0:
self.insert(self.header.value, 1)
self.header.value = item
return
node = self.header
i = 0
while i < index-1:
node = node.next
i += 1
n = node.next
node.next = NodeDual(item, nxt=n, pre=node)
if n:
n.prev = node.next
同样利用测试单链表的函数对双链表进行测试，
if __name__ == '__main__':
test(DoublyLinkedList())
得到结果
Show linked list:
None Init linked list:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=8><->
<NodeDual, prev=xd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=None> Insert element:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=None> Append element:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=None> Find element:
xd Find previous element:
6 Delete element:
<NodeDual, prev=None, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=None> Find element not exist:
None Insert element to header:
<NodeDual, prev=None, value=cc, next=1><->
<NodeDual, prev=cc, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=None> Clear linked list:
None Current length: 0 Is empty: True
2 循环双链表
循环双链表类似于双链表，但是将表的头尾两个结点相连，形成了一个循环链表结构，即头结点的前一个结点为尾结点，尾结点的下一个结点为头结点。
Doubly linked list with loop:
________________________________________________________
| |
<===> node_1 <---> node_2 <---> node_3 <---> node_4 <===>
|________________________________________________________|
首先导入需要的结点和双链表类以及测试函数，
from linked_list_doubly import NodeDual, DoublyLinkedList, test
接着定义循环双链表类，对链表的显示输出同样要先遍历链表，而这里的遍历函数需要额外增加一个判断条件，即当再次遇到头结点时，遍历停止，否则将无限循环遍历下去。
class DoublyLinkedListLoop(DoublyLinkedList):
"""
Doubly linked list with loop:
________________________________________________________
| |
<===> node_1 <---> node_2 <---> node_3 <---> node_4 <===>
|________________________________________________________|
"""
def __str__(self):
def _traversal(self):
node = self.header
while node and node.next is not self.header:
yield node
node = node.next
yield node
return '<->\n'.join(map(lambda x: str(x), _traversal(self)))
循环双链表的生成函数比双链表多了一个步骤，即将双链表的头尾结点相接。
def init(self, iterable=()):
if not iterable:
return
self.header = NodeDual(iterable[0]) # header value
pre = None
node = self.header
for i in iterable[1:]: # add all node
node.prev = pre
node.next = NodeDual(i)
pre = node
node = node.next
node.prev = pre node.next = self.header
self.header.prev = node
用于获取表长度的属性方法同样需要更改，增加一个头结点判断来终止循环遍历。
@property
def length(self):
if self.header is None:
return 0
node = self.header
i = 1
while node.next is not self.header:
node = node.next
i += 1
return i
两个查找函数也是同样需要加入头结点判断来停止循环。
def find(self, item):
node = self.header
while node.next is not self.header and node.value != item:
node = node.next
if node.value == item:
return node
return None def find_previous(self, item):
node = self.header
while node.next is not self.header and node.next.value != item:
node = node.next
if node.next is not self.header and node.next.value == item:
return node
return None
最后用测试函数进行测试，
if __name__ == '__main__':
test(DoublyLinkedListLoop())
测试结果为
Show linked list:
None Init linked list:
<NodeDual, prev=9, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=8><->
<NodeDual, prev=xd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=1> Insert element:
<NodeDual, prev=9, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=1> Append element:
<NodeDual, prev=10, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xd><->
<NodeDual, prev=6, value=xd, next=xxd><->
<NodeDual, prev=xd, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=1> Find element:
xd Find previous element:
6 Delete element:
<NodeDual, prev=10, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=1> Find element not exist:
None Insert element to header:
<NodeDual, prev=10, value=cc, next=1><->
<NodeDual, prev=cc, value=1, next=2><->
<NodeDual, prev=1, value=2, next=3><->
<NodeDual, prev=2, value=3, next=4><->
<NodeDual, prev=3, value=4, next=5><->
<NodeDual, prev=4, value=5, next=6><->
<NodeDual, prev=5, value=6, next=xxd><->
<NodeDual, prev=6, value=xxd, next=8><->
<NodeDual, prev=xxd, value=8, next=9><->
<NodeDual, prev=8, value=9, next=10><->
<NodeDual, prev=9, value=10, next=cc> Clear linked list:
None Current length: 0 Is empty: True
相关阅读
1. 单链表
Python与数据结构[0] -> 链表/LinkedList[1] -> 双链表与循环双链表的 Python 实现的更多相关文章
- Python与数据结构[0] -> 链表/LinkedList[0] -> 单链表与带表头单链表的 Python 实现
单链表 / Linked List 目录 单链表 带表头单链表 链表是一种基本的线性数据结构,在C语言中,这种数据结构通过指针实现,由于存储空间不要求连续性,因此插入和删除操作将变得十分快速.下面将利 ...
- Python与数据结构[0] -> 链表/LinkedList[2] -> 链表有环与链表相交判断的 Python 实现
链表有环与链表相交判断的 Python 实现 目录 有环链表 相交链表 1 有环链表 判断链表是否有环可以参考链接, 有环链表主要包括以下几个问题(C语言描述): 判断环是否存在: 可以使用追赶方法, ...
- python基础笔记-0
python中数据结构,主要有列表.元组.字典.集合. python中最基本数据结构是序列(sequence).序列中每个元素被分配一个序号——即元素位置,也成为索引.第一个索引是0,第二个是1,以此 ...
- C语言版本：循环单链表的实现
SClist.h #ifndef __SCLIST_H__ #define __SCLIST_H__ #include<cstdio> #include<malloc.h> # ...
- Python与数据结构[1] -> 栈/Stack[0] -> 链表栈与数组栈的 Python 实现
栈 / Stack 目录 链表栈 数组栈 栈是一种基本的线性数据结构(先入后出FILO),在 C 语言中有链表和数组两种实现方式,下面用 Python 对这两种栈进行实现. 1 链表栈 链表栈是以单链 ...
- python实现数据结构单链表
#python实现数据结构单链表 # -*- coding: utf-8 -*- class Node(object): """节点""" ...
- Java数据结构-线性表之单链表LinkedList
线性表的链式存储结构,也称之为链式表,链表:链表的存储单元能够连续也能够不连续. 链表中的节点包括数据域和指针域.数据域为存储数据元素信息的域,指针域为存储直接后继位置(一般称为指针)的域. 注意一个 ...
- 数据结构之链表(LinkedList)(三)
数据结构之链表(LinkedList)(二) 环形链表 顾名思义 环形列表是一个首尾相连的环形链表 示意图 循环链表的特点是无须增加存储量,仅对表的链接方式稍作改变,即可使得表处理更加方便灵活. 看一 ...
- 数据结构之链表(LinkedList)(二）
数据结构之链表(LinkedList)(一) 双链表 上一篇讲述了单链表是通过next 指向下一个节点,那么双链表就是指不止可以顺序指向下一个节点,还可以通过prior域逆序指向上一个节点 示意图: ...
随机推荐
- USACO Section1.5 Number Triangles 解题报告
numtri解题报告 —— icedream61 博客园(转载请注明出处)--------------------------------------------------------------- ...
- python2.7写入文件时指定编码为utf-8
python3.0可以这样写 f = open('ufile.log', 'w', 'utf-8') 但在python2.7中open()没有编码参数,如上那样写会报错,可以使用如下模块 impo ...
- SecureCRT自动登录跳板机/堡垒机并连接目标机器
公司登录目标服务器,需要先登录跳板机(堡垒机),然后再登录目标机器,一共需要4.5步. MAC或LINUX机器可以写.SH脚本,那WINDOWS有没有一键登陆的方法呢? 常用的SecureCRT工具就 ...
- PAT 1070 结绳
https://pintia.cn/problem-sets/994805260223102976/problems/994805264706813952 给定一段一段的绳子,你需要把它们串成一条绳. ...
- nginx限速白名单配置
在<nginx限制连接数ngx_http_limit_conn_module模块>和<nginx限制请求数ngx_http_limit_req_module模块>中会对所有的I ...
- babelrc配置
{ "presets": [ ["env", { // webapck2/3必须配置,放弃使用babel的模块化,使用webpack的模块化,webpack1不 ...
- 《R语言实战》读书笔记--第四章 基本数据管理
本章内容: 操纵日期和缺失值 熟悉数据类型的转换 变量的创建和重编码 数据集的排序,合并与取子集 选入和丢弃变量 多说一句,数据预处理的时间是最长的……确实是这样的,额. 4.1一个示例 4.2创建新 ...
- Java中Collections的frequency方法
注:调用此方法时需要根据自己的须由复写Objects的equals方法 创建复写了equals方法的对象类 public class Student { private String name; pr ...
- CentOS下SVN使用
1. 介绍 这里想在CentOS上搭建的是基于http访问的SVN Server 2. 软件 安装相关软件 yum install httpd httpd-devel mod_dav_svn subv ...
- UVALIVE 3571 Visible Lattice Points
就欧拉函数然后地推一下. #include <map> #include <set> #include <list> #include <cmath> ...