python遍历链表_四种常见链表的实现及时间复杂度分析(Python3版)
class Node(object):
"""单节点"""
def __init__(self, elem):
self.elem = elem
self.next = None
class DoubleNode(Node):
"""双节点"""
def __init__(self, elem):
super(DoubleNode, self).__init__(elem)
self.prev = None
class SingleLinkList(object):
"""单链表"""
def __init__(self, node=None):
self.head = node
def is_empty(self) -> bool:
"""链表是否为空 O(1)"""
return self.head is None
def length(self) -> int:
"""链表长度 O(n)"""
count, cur = 0, self.head
while cur is not None:
cur = cur.next # 不要写错cur = self.head.next, self.__next不是活动指针
count += 1
return count
def traversing(self) -> '':
"""遍历所有节点 O(n)"""
cur = self.head # 不是 self._head
while cur is not None:
print(cur.elem, end=' ')
cur = cur.next
return ''
def add(self, item) -> None:
"""头部添加节点 O(1)"""
node = Node(item)
node.next = self.head
self.head = node
def append(self, item) -> None:
"""尾部添加节点 O(n)"""
node = Node(item)
cur = self.head
if self.is_empty():
self.head = node
else:
while cur.next is not None:
cur = cur.next
cur.next = node
def insert(self, position: int, item) -> None:
"""
节点插入到某个位置 O(n)
:param position: 0表示第1个位置
:param item:
:return: None
"""
if position <= 0:
self.add(item)
elif position >= self.length():
self.append(item)
else:
node = Node(item)
count, cur = 1, self.head
while count < position:
cur = cur.next
count += 1
node.next = cur.next
cur.next = node
def remove(self, item) -> None:
"""删除链表中的一个节点 O(n)"""
pre, cur = None, self.head
while cur is not None:
if cur.elem == item:
if cur == self.head:
self.head = cur.next
break # 只remove第一个元素
pre.next = cur.next
break
pre = cur
cur = cur.next
def search(self, item) -> bool:
"""查找节点是否存在 O(n)"""
cur = self.head
while cur is not None:
if cur.elem == item:
return True
cur = cur.next
return False
class SingleCycleLinkList(SingleLinkList):
"""单向循环链表"""
def __init__(self, node=None):
if node:
node.next = node
super(SingleCycleLinkList, self).__init__(node=node)
def length(self) -> int:
"""链表长度 O(n)"""
if self.is_empty():
return 0
count, cur = 1, self.head
while cur.next != self.head:
cur = cur.next # 不要写错cur = self.head.next, self.__next不是活动指针
count += 1
return count
def traversing(self) -> '':
"""遍历所有节点 O(n)"""
if not self.is_empty():
cur = self.head # 不是 self._head
while cur.next != self.head:
print(cur.elem, end=' ')
cur = cur.next
print(cur.elem, end=' ')
return ''
def add(self, item) -> None:
"""头部添加节点 O(n)"""
node = Node(item)
if self.is_empty():
self.head = node
node.next = node
else:
cur = self.head
while cur.next != self.head:
cur = cur.next
# 退出while循环之后cur指向尾结点
node.next = self.head
self.head = node
cur.next = self.head
def append(self, item) -> None:
"""尾部添加节点 O(n)"""
node = Node(item)
if self.is_empty():
self.head = node
node.next = node
else:
cur = self.head
while cur.next != self.head:
cur = cur.next
cur.next = node
node.next = self.head
def insert(self, position: int, item) -> None:
"""
节点插入到某个位置 O(n)
:param position: 0表示第1个位置
:param item:
:return: None
"""
if position <= 0:
self.add(item)
elif position >= self.length():
self.append(item)
else:
node = Node(item)
count, cur = 1, self.head
while count < position:
cur = cur.next
count += 1
node.next = cur.next
cur.next = node
def remove(self, item) -> None:
"""删除链表中的一个节点 O(n)"""
if self.is_empty():
return
pre, cur = None, self.head
while cur.next != self.head:
if cur.elem == item:
# 移除头结点
if cur == self.head:
rear = self.head
while rear.next != self.head:
rear = rear.next
self.head = cur.next
rear.next = self.head
# 移除中间节点
else:
pre.next = cur.next
return # 结束。只remove第一个元素
pre = cur
cur = cur.next
# 移除尾结点
if cur.elem == item:
if cur == self.head:
self.head = None
else:
pre.next = self.head # 或者 pre.next = cur.next
def search(self, item) -> bool:
"""查找节点是否存在 O(n)"""
if self.is_empty():
return False
else:
cur = self.head
while cur.next != self.head:
if cur.elem == item:
return True
cur = cur.next
return cur.elem == item
class DoubleLinkList(SingleLinkList):
"""双链表"""
def add(self, item) -> None:
"""头部添加节点 O(1)"""
node = DoubleNode(item)
node.next = self.head
self.head = node
if node.next: # 当原链表为空时
node.next.prev = node
def append(self, item) -> None:
"""尾部添加节点 O(n)"""
node = DoubleNode(item)
cur = self.head
if self.is_empty():
self.head = node
else:
while cur.next is not None:
cur = cur.next
cur.next = node
node.prev = cur
def insert(self, position: int, item) -> None:
"""
节点插入到某个位置 O(n)
:param position: 0表示第1个位置
:param item:
:return: None
"""
if position <= 0:
self.add(item)
elif position >= self.length():
self.append(item)
else:
node = DoubleNode(item)
count, cur = 1, self.head
while count < position:
cur = cur.next
count += 1
node.next = cur.next
node.prev = cur
cur.next.prev = node
cur.next = node
def remove(self, item) -> None:
"""删除链表中的一个节点 O(n)"""
cur = self.head
while cur is not None:
if cur.elem == item:
if cur == self.head:
self.head = cur.next
if self.head: # 只有一个节点的特殊情况
cur.next.prev = None
else:
cur.prev.next = cur.next
if cur.next:
cur.next.prev = cur.prev
break # 只remove第一个元素
cur = cur.next
class DoubleCycleLinkList(SingleCycleLinkList):
"""双向循环链表"""
def __init__(self, node=None):
if node:
node.next = node
node.prev = node
super(DoubleCycleLinkList, self).__init__(node=node)
def add(self, item) -> None:
"""头部添加节点 O(n)"""
node = DoubleNode(item)
if self.is_empty():
self.head = node
node.next = node
node.prev = node
else:
cur = self.head
while cur.next != self.head:
cur = cur.next
# 退出while循环之后cur指向尾结点,双向循环链表需要改动5个指针
node.next = self.head # 1.node.next指向原来的头结点
node.prev = cur # 2.node.prev指向尾结点,当前cur指向的节点
cur.next.prev = node # 3.原来头结点的prev指向要插入的node
self.head = node # 4.self.head指向要插入的node
cur.next = node # 5.尾结点的next指向要插入的node
def append(self, item) -> None:
"""尾部添加节点 O(n)"""
node = DoubleNode(item)
if self.is_empty():
self.head = node
node.next = node
node.prev = node
else:
cur = self.head
# 退出while循环之后cur指向尾结点,双向循环链表需要改动4个指针
while cur.next != self.head:
cur = cur.next
cur.next.prev = node # 1.原来头结点的.prev指向要插入的node
cur.next = node # 2.原来尾结点.next指向要插入的node
node.prev = cur # 3.node.prev指向原来的尾节点
node.next = self.head # 4.node.next指向头结点
def insert(self, position: int, item) -> None:
"""
节点插入到某个位置 O(n)
:param position: 0表示第1个位置
:param item:
:return: None
"""
if position <= 0:
self.add(item)
elif position >= self.length():
self.append(item)
else:
node = DoubleNode(item)
count, cur = 1, self.head
while count < position:
cur = cur.next
count += 1
node.next = cur.next
node.prev = cur
cur.next.pre = node
cur.next = node
def remove(self, item) -> None:
"""删除链表中的一个节点 O(n)"""
if self.is_empty():
return
cur = self.head
while cur.next != self.head:
if cur.elem == item:
# 移除头结点
if cur == self.head:
cur.prev.next = cur.next
cur.next.prev = cur.prev
self.head = cur.next
# 移除中间节点
else:
cur.prev.next = cur.next
cur.next.prev = cur.prev
return # 结束。只remove第一个元素
cur = cur.next
# 移除尾结点
if cur.elem == item:
if cur == self.head: # 当链表只有一个节点时
self.head = None
else:
cur.next.prev = cur.prev
cur.prev.next = cur.next
if __name__ == '__main__':
print("----single_link_list-----")
single_link_list = SingleLinkList()
single_link_list.remove('test')
print(single_link_list.is_empty(), single_link_list.length())
single_link_list.insert(-1, 'zhao')
print(single_link_list.is_empty(), single_link_list.length())
single_link_list.insert(3, 'zi')
print(single_link_list.length())
single_link_list.append('yang')
single_link_list.add("head")
single_link_list.insert(4, "tail")
print(single_link_list.traversing())
single_link_list.remove(1)
print(single_link_list.traversing())
single_link_list.remove("head")
print(single_link_list.traversing())
single_link_list.remove("tail")
print(single_link_list.traversing())
single_link_list.remove('zi')
print(single_link_list.traversing())
print("\n----single_cycle_link_list-----")
single_cycle_link_list = SingleCycleLinkList()
single_cycle_link_list.remove('test')
print(single_cycle_link_list.is_empty(), single_cycle_link_list.length())
single_cycle_link_list.insert(-1, 'zhao')
print(single_cycle_link_list.is_empty(), single_cycle_link_list.length())
single_cycle_link_list.insert(3, 'zi')
print(single_cycle_link_list.length())
single_cycle_link_list.append('yang')
single_cycle_link_list.add("head")
single_cycle_link_list.insert(4, "tail")
print(single_cycle_link_list.traversing())
single_cycle_link_list.remove(1)
print(single_cycle_link_list.traversing())
single_cycle_link_list.remove("head")
print(single_cycle_link_list.traversing())
single_cycle_link_list.remove("tail")
print(single_cycle_link_list.traversing())
single_cycle_link_list.remove('zi')
print(single_cycle_link_list.traversing())
print("\n----double_link_list-----")
double_link_list = DoubleLinkList()
double_link_list.remove('test')
print(double_link_list.is_empty(), double_link_list.length())
double_link_list.insert(-1, 'zhao')
print(double_link_list.is_empty(), double_link_list.length())
double_link_list.insert(3, 'zi')
print(double_link_list.length())
double_link_list.append('yang')
double_link_list.add("head")
double_link_list.insert(4, "tail")
print(double_link_list.traversing())
double_link_list.remove(1)
print(double_link_list.traversing())
double_link_list.remove("head")
print(double_link_list.traversing())
double_link_list.remove("tail")
print(double_link_list.traversing())
double_link_list.remove('zi')
print(double_link_list.traversing())
print("\n----double_cycle_link_list-----")
double_cycle_link_list = DoubleCycleLinkList()
double_cycle_link_list.remove('test')
print(double_cycle_link_list.is_empty(), double_cycle_link_list.length())
double_cycle_link_list.insert(-1, 'zhao')
print(double_cycle_link_list.is_empty(), double_cycle_link_list.length())
double_cycle_link_list.insert(3, 'zi')
print(double_cycle_link_list.length())
double_cycle_link_list.append('yang')
double_cycle_link_list.add("head")
double_cycle_link_list.insert(4, "tail")
print(double_cycle_link_list.traversing())
double_cycle_link_list.remove(1)
print(double_cycle_link_list.traversing())
double_cycle_link_list.remove("head")
print(double_cycle_link_list.traversing())
double_cycle_link_list.remove("tail")
print(double_cycle_link_list.traversing())
double_cycle_link_list.remove('zi')
print(double_cycle_link_list.traversing())
python遍历链表_四种常见链表的实现及时间复杂度分析(Python3版)相关推荐
- python 释放链表节点_四种常见链表的实现及时间复杂度分析(Python3版)
四种常见的链表包括:单向链表,单向循环链表,双向链表,双向循环链表. 要实现的链表操作包括 - is_empty() 判断链表是否为空 - length() 求链表长度 - traversing() ...
- java post 多个参数_四种常见的post请求中的参数形式
1).HTTP 协议是以 ASCII 码 传输,建立在 TCP/IP 协议之上的应用层规范.规范把 HTTP 请求分为三个部分:状态行.请求头.消息主体. 2).协议规定 POST 提交的数据必须放在 ...
- EZEMC测试软件_四种常见的EMC仿真软件介绍
EMC仿真软件能够为我们提供了一个非常有效的高频和高速电磁仿真设计工具,它集高速电路建模.仿真和优化为一体,用仿真代替实验,可以快速的帮助工程师完成高速电路EMC设计,实现信号完整性,减少研发费用,缩 ...
- mysql四种常用的索引_四种常见的索引类型
主键索引:数据记录里面不能有 null,数据内容不能重复,在一张表里面不能有 多个主键索引. 普通索引:使用字段关键字建立的索引,主要是提高查询速度 唯一索引:字段数据是唯一的,数据内容里面能否为 n ...
- python遍历字典的四种方法
根据key值遍历 >>> a {'a': '1', 'b': '2', 'c': '3'} >>> for key in a:print(key+':'+a[key ...
- Python遍历字典的四种方法对比
#!/usr/bin/python from time import clockl = [(x,x) for x in xrange (10000000)] d = dict(l) t0 = cloc ...
- 转载:JSON技术的调研报告(四种常见的JSON格式对比及分析)
转载自地址:http://www.cnblogs.com/kunpengit/p/4001680.html 一 .各个JSON技术的简介和优劣 1.json-lib json-lib最开始的也是应用最 ...
- JSON技术的调研报告(四种常见的JSON格式对比及分析)
https://www.cnblogs.com/renmengkai/p/9183775.html
- python数据对比找不同_利用Python读取文件的四种不同方法比对
利用Python读取文件的四种不同方法比对 大家都知道Python 读文件的方式多种多样,但是当需要读取一个大文件的时候,不同的读取方式会有不一样的效果.下面就来看看详细的介绍吧. 场景 逐行读取一个 ...
最新文章
- 搜索引擎技术之概要预览
- 为什么输出流会有一个flsh_交流会| “流量”还是“留量”,如何成为电商风口上的赢家?...
- 高德纳咨询公司(Gartner)预测:2019年七大人工智能科技趋势
- 解决启动httpd报: apr_sockaddr_info_get() failed for错误
- MATLAB与图像处理(一):图像中结构张量的求法(Structure Tensor)
- python定义只有一个元素的元组
- Luogu P1525 【关押罪犯】
- MySQL事务及隔离级别详解
- day4-Python学习笔记(七)函数与模块
- HDOJ水题集合2:最短路(Dijkstra)
- 关于msgpack序列化后的消息包是否再压缩
- Linux kernel tick发起调度软中断函数调用图
- 计算机图形学-画太极
- 服务器网卡多路径配置文件,IPSAN(五)IPSAN多路径设置(客户端)
- 微信24小时到账_最新微信转账延迟24小时到账骗局
- 计算机一级用写在简历里面吗,写简历要小心,简历填写最忌讳的是什么,你知道吗?...
- java根据文件字符换行_java操作txt文本(一):遇到指定字符换行
- react--1.react环境搭建、JSX语法、注释、样式、列表渲染、定义单个组件、eact Props、react State
- VisionPro如何引用VPP?
- 专有名词collect
热门文章
- mysql 删除表时外键约束_MySQL删除表的时候忽略外键约束的简单实现
- 电大计算机应用基础考试复习,电大 《计算机应用基础》形考作业2
- 几张一模一样的照片_每隔几百年,就会出现一个和你一模一样的人?这些照片怎么解释?...
- could not open extension control file “/usr/share/postgresql/9.1/extension/dblink.control“
- 基于JAVA+SpringMVC+Mybatis+MYSQL的校园失物招领系统
- 基于JAVA+Servlet+JSP+MYSQL的运动会管理系统
- 基于JAVA+Servlet+JSP+MYSQL的幼儿园管理系统
- LeetCode:交替打印【1115】
- Appium+python自动化(十六)- ADB命令,知否知否,应是必知必会(超详解)
- 章节三、2-方法_演示实例