单链表 / Linked List


目录

  1. 单链表
  2. 带表头单链表

链表是一种基本的线性数据结构,在C语言中,这种数据结构通过指针实现,由于存储空间不要求连续性,因此插入和删除操作将变得十分快速。下面将利用Python来完成单链表的实现。

1 单链表

不带表头的单链表通常形式如下,

node_1 -> node_2 -> node_3 -> node_4

完整代码

 class Node:
def __init__(self, val=None, nxt=None):
self.value = val
self.next = nxt def __str__(self):
return str(self.value) class LinkedList:
"""
Linked list:
node_1 -> node_2 -> node_3 -> node_4
"""
def __init__(self, iterable=()):
self.header = None
if iterable:
self.init(iterable) def __str__(self):
def _traversal(self):
node = self.header
while node and node.next:
yield node
node = node.next
yield node
return '->'.join(map(lambda x: str(x), _traversal(self))) def init(self, iterable=()):
# Note: use empty tuple rather than list to init iterable
if not iterable:
return
self.header = Node(iterable[0]) # header value
node = self.header
for i in iterable[1:]: # add all node
node.next = Node(i)
node = node.next def show(self):
print(self) @property
def length(self):
if self.header is None:
return 0
node = self.header # node pointer points to header
i = 1
while node.next:
node = node.next # node pointer move to next
i += 1
return i @property
def is_empty(self):
return self.header is None def clear(self):
self.__init__()
# self.header = None def append(self, item):
self.insert(item, self.length) def find(self, item):
node = self.header
while node.next 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 and node.next.value != item:
node = node.next
if node.next and node.next.value == item:
return node
return None def delete(self, item):
'''
node_1 -- X --> node_2 -----> node_3
\ /
\ /
------------------
'''
prev = self.find_previous(item)
if prev:
prev.next = prev.next.next def insert(self, item, index):
'''
----> node_2 ---
/ \
/ \
node_1 ------- X ---------> node_3 '''
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 = Node(item, n) def test(li):
print('Show linked list:')
li.show() print('\nInit linked list:')
li.init([1, 2, 3, 4, 5, 6, 'xd', 8, 9])
li.show() print('\nInsert element:')
li.insert('xxd', -3)
li.show() print('\nAppend element:')
li.append('')
li.show() e = 'xd'
print('\nFind element:')
x = li.find(e)
print(x.value if x else x)
print('\nFind previous element:')
x = li.find_previous(e)
print(x.value if x else x) print('\nDelete element:')
li.delete('xd')
li.show() print('\nFind element not exist:')
x = li.find(e)
print(x.value if x else x) print('\nInsert element to header:')
li.insert('cc', 0)
li.show() print('\nClear linked list:')
li.clear()
li.show() print('\nCurrent length: %s' % li.length)
print('\nIs empty: %s' % li.is_empty) if __name__ == '__main__':
test(LinkedList())

分段解释

首先,需要定义一个结点类(在C语言中则使用结构体进行定义),其中包括两个基本属性,当前值和下个结点。由于Python中无法使用类似C语言中的指针,因此只能通过变量的引用来实现类似指针操作的功能。为了更好的显示结点,这里重载了结点的内置函数__str__。

 class Node:
def __init__(self, val=None, nxt=None):
self.value = val
self.next = nxt def __str__(self):
return str(self.value)

接着,我们需要。定义一个链表类,并利用前面的结点来构建这个链表。链表类中包含了一个头结点属性,在初始化函数中,首先将头结点赋值None,类似于在C语言中将头结点指针指向NULL。初始化方法中定义了一个默认参数,使得链表可以在实例化的时候利用传入的可迭代对象进行链表生成。

 class LinkedList:
"""
Linked list:
node_1 -> node_2 -> node_3 -> node_4
"""
def __init__(self, iterable=()):
self.header = None
if iterable:
self.init(iterable)

重载链表的__str__方法,在显示链表的时候会对链表进行遍历,然后以更加清晰的方式显示在输出终端上。

     def __str__(self):
def _traversal(self):
node = self.header
while node and node.next:
yield node
node = node.next
yield node
return '->'.join(map(lambda x: str(x), _traversal(self)))

定义链表的生成函数,函数中接收可迭代对象并生成新的链表。注意这里最好使用不可变的元组而不是可变的列表。

在生成时,首先将第一个元素作为头结点,然后依次将每个结点的next属性引用指向下一个结点。

     def init(self, iterable=()):
# Note: use empty tuple rather than list to init iterable
if not iterable:
return
self.header = Node(iterable[0]) # header value
node = self.header
for i in iterable[1:]: # add all node
node.next = Node(i)
node = node.next

链表的show方法,由于已经重载了__str__方法,这里只需要print自身即可。

     def show(self):
print(self)

链表的length属性方法,用于返回链表的长度,利用装饰器定义成属性方法,调用时遍历链表计算长度最后返回即可。

     @property
def length(self):
if self.header is None:
return 0
node = self.header # node pointer points to header
i = 1
while node.next:
node = node.next # node pointer move to next
i += 1
return i

链表的is_empty属性方法,用于检测链表是否为空,只需要查看头结点是否为None即可。

     @property
def is_empty(self):
return self.header is None

链表的clear方法,用于清空链表,可以选择直接初始化链表或将链表的头结点指向None。

     def clear(self):
self.__init__()
# self.header = None

链表的append方法,用于在链表尾部添加一个元素结点,这里只要直接调用后面的insert方法并插入到链表长度的那个位置即可。

     def append(self, item):
self.insert(item, self.length)

链表的find方法,用于在链表中查找并返回某个结点,查找时会从链表的头部开始,遍历查找,直到找到查找的值或遇到None,这里的find方法有两点需要注意:

  1. 查找是依据元素的值进行查找,返回找到的第一个结点;
  2. 这里的查找方法如果遇到有环链表将无法自行检测退出

最后返回查找到的结点或None。

     def find(self, item):
node = self.header
while node.next and node.value != item:
node = node.next
if node.value == item:
return node
return None

find_previous与find类似,返回查找结点的前一个结点。

     def find_previous(self, item):
node = self.header
while node.next and node.next.value != item:
node = node.next
if node.next and node.next.value == item:
return node
return None

delete方法用于删除结点,基本思路在于,找到需要删除结点node_2的前一个结点node_1,将前一个结点node_1的next指针指向删除结点的下一个结点node_3,从而惰性删除了这个结点。

查找前一个结点可以使用前面定义的find_previous方法。

     def delete(self, item):
'''
node_1 -- X --> node_2 -----> node_3
\ /
\ /
------------------
'''
prev = self.find_previous(item)
if prev:
prev.next = prev.next.next

insert方法用于向链表中插入一个结点,

基本思路在于,找到需要插入的位置前后的两个结点node_1和node_3,将node_1.next指向需要插入的结点node_2,再将node_2.next指向node_3,便完成了插入操作。

若插入的位置为头结点之前,则会替换原来的头结点为新插入的结点。

同时,这里的插入函数还支持index为负数的情况,类似于列表的负数索引。

     def insert(self, item, index):
'''
----> node_2 ---
/ \
/ \
node_1 ------- X ---------> node_3 '''
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 = Node(item, n)

最后,定义一个测试函数用于测试链表的各种操作。

开始时显示空表

 def test(li):
print('Show linked list:')
li.show()

得到结果

Show linked list:
None

接着初始化链表元素

     print('\nInit linked list:')
li.init([1, 2, 3, 4, 5, 6, 'xd', 8, 9])
li.show()

得到结果

Init linked list:
1->2->3->4->5->6->xd->8->9

再向链表中插入元素

     print('\nInsert element:')
li.insert('xxd', -3)
li.show()

得到结果

Insert element:
1->2->3->4->5->6->xd->xxd->8->9

向链表末尾添加元素

     print('\nAppend element:')
li.append('')
li.show()

得到结果

Append element:
1->2->3->4->5->6->xd->xxd->8->9->10

查找元素

     e = 'xd'
print('\nFind element:')
x = li.find(e)
print(x.value if x else x)
print('\nFind previous element:')
x = li.find_previous(e)
print(x.value if x else x)

得到结果

Find element:
xd Find previous element:
6

删除元素

     print('\nDelete element:')
li.delete('xd')
li.show()

得到结果

Delete element:
1->2->3->4->5->6->xxd->8->9->10

查找不存在的元素

     print('\nFind element not exist:')
x = li.find(e)
print(x.value if x else x)

得到结果

Find element not exist:
None

替换头结点

     print('\nInsert element to header:')
li.insert('cc', 0)
li.show()

得到结果

Insert element to header:
cc->1->2->3->4->5->6->xxd->8->9->10

清空链表并查看链表信息

     print('\nClear linked list:')
li.clear()
li.show() print('\nCurrent length: %s' % li.length)
print('\nIs empty: %s' % li.is_empty)

得到结果

Clear linked list:
None Current length: 0 Is empty: True

2 带表头单链表

这种单链表带有一个标志结点,通常被称为表头或哑结点,表头通常位于位置0处,通常不会被改变。

Linked list with dummy header node:
Header -> node_1 -> node_2 -> node_3

带表头的单链表在实现时与不带表头的单链表类似,因此可以继承前面的单链表类来派生出一个带表头单链表类,其中需要进行修改和重载的方法主要有生成链表、判断链表为空和插入链表这几个方法。

 from linked_list import Node, LinkedList, test

 class LinkedListDummyHeader(LinkedList):
"""
Linked list with dummy header node:
Header -> node_1 -> node_2 -> node_3
"""
def __init__(self, iterable=()):
self.header = Node('Header', None)
if iterable:
self.init(iterable) def init(self, iterable=()):
if not iterable:
return
node = self.header
for i in iterable:
node.next = Node(i)
node = node.next @property
def is_empty(self):
return self.header.next is None
# if self.length == 1:
# return True
# return False def insert(self, item, index):
if index == 0:
return
super(LinkedListDummyHeader, self).insert(item, index) if __name__ == '__main__':
test(LinkedListDummyHeader())

__init__方法:

初始化时头结点不再指向None,而是指向表头。

init方法:

由于有表头的存在,因此创建初始链表的方法首先需要建立一个表头,再将所有元素依次加入链表中。

is_empty方法:

由于表头的存在,此时判断是否为空则可以根据表头指向结点是否为空,或链表长度是否为1来进行。

insert方法:

此处需要修改的地方在于当插入点为表头时,则应该直接返回或引发异常,无法修改表头。

最后利用单链表的测试函数进行测试得到结果

Show linked list:
Header Init linked list:
Header->1->2->3->4->5->6->xd->8->9 Insert element:
Header->1->2->3->4->5->6->xd->xxd->8->9 Append element:
Header->1->2->3->4->5->6->xd->xxd->8->9->10 Find element:
xd Find previous element:
6 Delete element:
Header->1->2->3->4->5->6->xxd->8->9->10 Find element not exist:
None Insert element to header:
Header->1->2->3->4->5->6->xxd->8->9->10 Clear linked list:
Header Current length: 1 Is empty: True

Python与数据结构[0] -> 链表/LinkedList[0] -> 单链表与带表头单链表的 Python 实现的更多相关文章

  1. Python与数据结构[1] -> 栈/Stack[0] -> 链表栈与数组栈的 Python 实现

    栈 / Stack 目录 链表栈 数组栈 栈是一种基本的线性数据结构(先入后出FILO),在 C 语言中有链表和数组两种实现方式,下面用 Python 对这两种栈进行实现. 1 链表栈 链表栈是以单链 ...

  2. Python与数据结构[2] -> 队列/Queue[0] -> 数组队列的 Python 实现

    队列 / Queue 数组队列 数组队列是队列基于数组的一种实现,其实现类似于数组栈,是一种FIFO的线性数据结构. Queue: <--| 1 | 2 | 3 | 4 | 5 |<-- ...

  3. [H5表单]html5自带表单验证体验优化及提示气泡修改

    慕课网之前录制的视频,js/jquery各种宽高的理解和应用,最近终于上线了.还有一个html5左侧导航没有上线!最近慕课网系列课程让我录制一个html5表单验证的课程.今天就稍微说一下表单验证!另外 ...

  4. Python与数据结构[4] -> 散列表[0] -> 散列表与散列函数的 Python 实现

    散列表 / Hash Table 散列表与散列函数 散列表是一种将关键字映射到特定数组位置的一种数据结构,而将关键字映射到0至TableSize-1过程的函数,即为散列函数. Hash Table: ...

  5. Python与数据结构[3] -> 树/Tree[0] -> 二叉树及遍历二叉树的 Python 实现

    二叉树 / Binary Tree 二叉树是树结构的一种,但二叉树的每一个节点都最多只能有两个子节点. Binary Tree: 00 |_____ | | 00 00 |__ |__ | | | | ...

  6. Python与数据结构[4] -> 散列表[2] -> 开放定址法与再散列的 Python 实现

     开放定址散列法和再散列 目录 开放定址法 再散列 代码实现 1 开放定址散列法 前面利用分离链接法解决了散列表插入冲突的问题,而除了分离链接法外,还可以使用开放定址法来解决散列表的冲突问题. 开放定 ...

  7. Python与数据结构[4] -> 散列表[1] -> 分离链接法的 Python 实现

    分离链接法 / Separate Chain Hashing 前面完成了一个基本散列表的实现,但是还存在一个问题,当散列表插入元素冲突时,散列表将返回异常,这一问题的解决方式之一为使用链表进行元素的存 ...

  8. Python与数据结构[0] -> 链表/LinkedList[1] -> 双链表与循环双链表的 Python 实现

    双链表 / Doubly Linked List 目录 双链表 循环双链表 1 双链表 双链表和单链表的不同之处在于,双链表需要多增加一个域(C语言),即在Python中需要多增加一个属性,用于存储指 ...

  9. Python与数据结构[0] -> 链表/LinkedList[2] -> 链表有环与链表相交判断的 Python 实现

    链表有环与链表相交判断的 Python 实现 目录 有环链表 相交链表 1 有环链表 判断链表是否有环可以参考链接, 有环链表主要包括以下几个问题(C语言描述): 判断环是否存在: 可以使用追赶方法, ...

随机推荐

  1. 《Cracking the Coding Interview》——第9章:递归和动态规划——题目3

    2014-03-20 03:01 题目:给定一个已按升序排序的数组,找出是否有A[i] = i的情况出现. 解法1:如果元素不重复,是可以严格二分查找的. 代码: // 9.3 Given a uni ...

  2. Tornado详解

    1.Tornado路由系统 1.1 Tornado程序示例 新建一个tornadodemo.py, import tornado.ioloop import tornado.web user_info ...

  3. IPMITool driver

    官网链接: https://docs.openstack.org/ironic/latest/admin/drivers/ipmitool.html IPMITool driver 概述IPMI(In ...

  4. git使用及一些配置、问题

    安装https://git-for-windows.github.io/ 一.绑定用户名.邮件地址 git config --global user.name "Your Name" ...

  5. 第1张 Maven简介 学习笔记

    什么是构建? 编译.运行单元测试.生成文档.打包和部署 Maven的应用: 构建工具 依赖管理工具 通过坐标系统定位到每一个构建(artifact) 项目信息管理工具 Maven对于项目目录结构.测试 ...

  6. 如何在CentOS7上改变网络接口名

    如何在CentOS7上改变网络接口名 传统上,Linux的网络接口被枚举为eth[0123...],但这些名称并不一定符合实际的硬件插槽,PCI位置,USB接口数量等,这引入了一个不可预知的命名问题( ...

  7. BZOJ2763 [JLOI2011]飞行路线 【分层图 + 最短路】

    题目 Alice和Bob现在要乘飞机旅行,他们选择了一家相对便宜的航空公司.该航空公司一共在n个城市设有业务,设这些城市分别标记为0到n-1,一共有m种航线,每种航线连接两个城市,并且航线有一定的价格 ...

  8. Codeforces Round #328 (Div. 2) C 数学

    C. The Big Race time limit per test 1 second memory limit per test 256 megabytes input standard inpu ...

  9. linux命令Netstat

    1.需求 了解Netstat命令 2.简介 命令用于显示各种网络相关信息,如网络连接,路由表,接口状态 (Interface Statistics),masquerade 连接,多播成员 (Multi ...

  10. Three Garlands~Educational Codeforces Round 35

    C. Three Garlands time limit per test 2 seconds memory limit per test 256 megabytes input standard i ...