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域逆序指向上一个节点 示意图: ...
随机推荐
- 【Power of Two】cpp
题目: Given an integer, write a function to determine if it is a power of two. 代码: class Solution { pu ...
- NGUI注册事件的三种方式
1.第一种方式 当一个元素要执行某个方法,而这个方法在此元素赋予的脚本上有,那么直接会调用此方法,但此方法的名称必须是内置的固定名称,例如OnClick,OnMouseOver,OnMouseOut等 ...
- Mybatis + Oracle 批量insert的问题
这个问题真的太坑了 之前用ibatis+sql server 的foreach 很容易就写出来批量insert数据,但是测试后报错:SQL结束格式错误 现在换到银行工作,数据库也换成Oracle了 特 ...
- iptables的配置文件/etc/sysconfig/iptables不存在 linux防火墙开关命令
某linux服务器,使用 cat /etc/sysconfig/iptables命令时, 找不到文件. 1. service iptables status 使用该命令检查状态 如果之前找不到配置文件 ...
- juqery基本选择器和层级选择器
1.基本选择器,主要通过标签名称,样式,id等选择标签,如下代码是简单的使用 (1)根据标签或者样式筛选 <!DOCTYPE html> <html lang="en&qu ...
- Codeforces Round #327 (Div2) A~E
CodeForces 591A 题意:在距离为L的两端A,B,相向发射魔法,a(以P1的速度)-->B,A<--b(以P2的速度).假设a-->B,途中相遇,则返回到原点A<- ...
- [转] Linux命令行编辑常用键
ctrl + a 将光标移动到命令行开头相当于VIM里shift+^ ctrl + e 将光标移动到命令行结尾处相当于VIM里shift+$ ctrl + 方向键左键 光标移动到前一个单词开头 ctr ...
- WinDbg分析dump文件排查bug
文章:WinDbg-如何抓取dump文件 命令: cd C:\Windows\System32\inetsrv appcmd list wp 可以查看各个站点的pid
- 【bzoj1195】[HNOI2006]最短母串 AC自动机+状态压缩+BFS最短路
原文地址:http://www.cnblogs.com/GXZlegend/p/6825226.html 题目描述 给定n个字符串(S1,S2,„,Sn),要求找到一个最短的字符串T,使得这n个字符串 ...
- Rust安装配置
Rust安装配置 话说前面: 如果你 之前安装过老版本的 rust 请先卸载 我说的是以 msi 文件安装的那种, 请进控制面板–> 程序中进行卸载 首先 下载官网 的 rustup-init. ...