python进阶笔记(1)——单向链表、单向循环链表、双向链表
链表
链表(Linked list) 是一种常见的基础数据结构,是一种线性表,但是不像顺序表一样连续存储数据,而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。
链表结构可以充分利用计算机内存空间,实现灵活的内存动态管理。
单向链表
单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值。
对单链表进行操作需要先设置节点。
我们知道一个节点分两个区域,前一个区域存放数据,后一个区域存放下一个节点的位置信息(该位置信息默认为None,因为最后一个节点指向一个空地址)。
所以,代码如下:
class SingleNode:
def __init__(self,item):
# item存放数据
self.item = item
# next存放地址,初始默认为空
self.next = None
单链表的操作
对于单链表,常用的操作有如下几个:
- is_empty():判断链表是否为空。
- length():l链表长度。
- travel():遍历整个链表。
- add(item):链表头部添加元素。
- append(item):链表尾部添加元素。
- insert(pos,item):链表指定位置添加元素。
- remove(item):删除节点。
- search(item):查找节点。
这几个常用方法也是剩下两个链表的常用方法。
is_empty()
判断链表是否为空是进行增删改查之前的必要操作,因为没有该判断,控制台会报错——'NoneType' object has no attribute 'item'
。
class SingleNode:
def __init__(self,item):
# item存放数据
self.item = item
# next存放地址,初始默认为空
self.next = None
class SingleLinkList:
def __init__(self):
# 设置头节点(第一个节点)为空
self.__head = None
def empty(self):
"""判断链表是否为空"""
return self.__head == None # 这里是一个判断语句,返回一个布尔值True或False,是if...else...语句的简写
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.empty())
length()
读取链表长度对insert()等操作有极大帮助。
代码如下:
在原代码的基础上加上:
...
def length(self):
if self.is_empty():
return 0
count = 1
cur = self.__head # 设置临时节点
while cur != None: # 当临时节点的next不是指向头节点时进行循环
count += 1
cur = cur.next # 向下一个节点遍历
return count
...
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.is_empty())
print(list1.length())
travel()
在原代码的基础上加上:
...
def travel(self):
"""遍历链表"""
cur = self.__head # 设置临时节点在头节点位置
while cur != None:
print(cur.item) # item对应SingleNode类中的item
cur = cur.next # 遍历,让临时节点不断指向下一个节点
...
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.is_empty())
print(list1.length())
list1.travel()
add(item)
在原代码的基础上加上:
...
def add(self,item):
"""头部添加"""
node = SingleNode(item) # 生成节点,存储需要添加的数据
# 将生成节点的next指向头节点
node.next = self.__head
# 将node放入头节点
self.__head = node
...
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.is_empty())
print(list1.length())
list1.add('a')
list1.travel()
append(item)
在原代码的基础上加上:
...
def append(self,item):
"""尾部添加"""
node = SingleNode(item)
cur = self.__head
while cur.next != None: # 只要临时指针的下一个节点不为空,就继续往下遍历,直到最后一个
cur = cur.next # 这里cur已经是最后一个节点了
cur.next = node # cur.next是个空节点,所以将node放入该节点即为尾部添加
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.is_empty())
print(list1.length())
list1.add('a')
list1.append(1)
list1.travel()
insert(pos,item)
在原代码的基础上加上:
...
def insert(self,pos,item):
"""指定位置插入"""
if pos <= 0:
# 头部插入
self.add(item)
elif pos > self.length()-1:
# 尾部插入
self.append(item)
else:
# 插入节点node
node = SingleNode(item)
# 遍历节点数初始值为0
count = 0
# 建立临时节点
cur = self.__head
# 开始遍历
while count < pos-1:
count += 1
cur = cur.next
# 注意点
# 先将插入节点的next指向临时节点的下一位节点位置
node.next = cur.next
# 再将临时节点的next指向node
cur.next = node
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.is_empty())
print(list1.length())
list1.add('a')
list1.append(1)
list1.insert(1,'n')
list1.travel()
注意点:当遍历结束后,节点插入的两句代码顺序不能弄错,因为=
符号是赋值符号,程序中代码说是指向,实际上是赋值,如果两句话反过来,cur.next
就会被node
占用,这个时候node.next
指向就不是cur的下个节点位置而是node了,也就是cur.next
被node
替代了。
remove(item)
在原代码的基础上加上:
...
def remove(self,item):
"""删除节点"""
cur = self.__head # 设置临时节点cur位于头节点
# 设置临时节点的前一个节点pre
pre = None
# 遍历
while cur != None:
# 当找到要删除的节点
if cur.item == item:
# 如果刚好是第一个,pre是None
if not pre:
# 这里cur位于头节点位置,意思是将头节点指向cur的下一个节点位置
self.__head = cur.next
else:
# 如果不是第一个,前一个节点pre的next指向当前(临时)节点的下一个节点
pre.next = cur.next
break
else:
# 同样的顺序不能出错
# 遍历,前一个节点向cur节点位置遍历
pre = cur
# cur向下一个节点位置遍历
cur = cur.next
search(item)
def search(self,item):
"""索引节点"""
# 设置临时节点位于头节点
cur = self.__head
# 遍历
while cur != None:
# cur所处节点与指定节点相符返回True,不符合继续向下遍历
if cur.item == item:
print('------')
return True
else:
cur = cur.next
else:
# 遍历完所有节点后,还没找到指定节点返回False
return False
单向循环链表
单向循环链表和单向链表的区别在于链表中最后一个节点的next域不再为None,而是指向链表的头节点。
即 cur.next = self.__head
下面是各个常用方法的实现,具体解释都在代码行里。
class SingleNode:
def __init__(self,item):
"""初始化单向循环链表"""
self.item = item
self.next = None
class SingleLinkList:
def __init__(self):
"""初始化头节点"""
self.__head = None
def is_empty(self):
return self.__head == None
def length(self):
"""链表长度"""
# 当链表为空
if self.is_empty():
return 0
# 当链表不为空,设置长度计数初始值为1,设置临时节点位于头节点
# 如果只有头节点,链表长度为1
count = 1
cur = self.__head
# 遍历,当临时节点的next不是指向头节点时
while cur.next != self.__head:
# 长度计数加1,cur开始向下移动
count += 1
cur = cur.next
# 遍历完成后,返回计数长度count
return count
def travel(self):
"""遍历"""
if self.is_empty():
return 0
# 建立临时节点cur
cur = self.__head
print(cur.item)
while cur.next != self.__head:
cur = cur.next
print(cur.item)
def add(self,item):
"""头部添加"""
# 建立节点node存储参数item
node = SingleNode(item)
# 当链表为空
if self.is_empty():
# 头节点存放指定节点元素
self.__head = node
# 由于单向循环链表的性质,其尾节点的next是指向头节点的,所以这里node的next也是指向头节点
node.next = self.__head
else:
# 如果不是空链表
# node的next指向头节点
node.next = self.__head
# 建立临时节点位于原头节点的位置
cur = self.__head
# 遍历,直到cur指向尾节点
while cur.next != self.__head:
cur = cur.next
# 此时cur的next指向node,也就是现在的头节点
cur.next = node
# 头节点指向node,此时头节点已经被node取代
self.__head = node
def append(self,item):
"""尾部添加"""
# 建立节点node存储参数item
node = SingleNode(item)
# 当链表为空
if self.is_empty():
# 和头部添加一样,直接将node放入头节点位置
self.__head = node
# node的next指向头节点
node.next = self.__head
else:
# 如果不是空链表
# 建立临时节点位于头节点位置
cur = self.__head
# 遍历到尾部节点
while cur.next != self.__head:
cur = cur.next
# 此时cur位于尾部节点,cur的next指向node
cur.next = node
# node的next指向头节点,形成单向循环链表
node.next = self.__head
def insert(self,pos,item):
"""插入节点"""
# pos表示节点位置,超出链表范围的情况有两个
if pos <= 0:
self.add(item)
elif pos > (self.length() - 1):
self.append(item)
else:
# 未超出链表范围
# 建立节点node存储参数item
node = SingleNode(item)
# 建立临时节点位于头节点位置
cur = self.__head
# 设置循环用参数
count = 0
# 遍历到pos所指位置,这里(pos-1)是因为计数从0开始
while count < (pos - 1):
count += 1
cur = cur.next
# node的next指向cur的下一个节点
node.next = cur.next
# cur的next指向node
cur.next = node
def remove(self,item):
"""删除节点"""
# 空链表返回0
if self.is_empty():
return 0
# 设置临时节点位于头节点
cur = self.__head
# 设置cur的前一个节点pre
pre = None
# 遍历
while cur.next != self.__head:
# 找到item
if cur.item == item:
# 如果刚好是第一个
if cur == self.__head:
# 设置临时节点tail
tail = self.__head
# tail节点遍历到尾节点
while tail.next != self.__head:
tail = tail.next
# 头节点指向cur的下一个节点
self.__head = cur.next
# 尾节点的next指向头节点
tail.next = self.__head
else:
# 如果不是第一个,pre的next直接指向cur(即将被删除的节点)的下一个节点
pre.next = cur.next
# 返回退出内循环
return
else:
# 没找到则继续往下遍历,pre指向cur的位置,
pre = cur
# cur指向cur的下一个位置
cur = cur.next
# cur在最后,要删除最后一个节点
if cur.item == item:
# 如果只有一个节点
if cur.next == self.__head:
# 头节点为None
self.__head = None
else:
# 否则pre的next指向头节点
pre.next = self.__head
def search(self,item):
"""查询链表元素"""
# 空链表返回0
if self.is_empty():
return 0
# 设置临时节点cur位于头节点
cur = self.__head
# 当查询的元素刚好位于头节点时
if cur.item == item:
return True
# 当查询的元素位于除头节点外的节点时,开始遍历
while cur.next != self.__head:
# 找到元素
if cur.item == item:
return True
# 没找到继续遍历
cur = cur.next
# 遍历完还没找到直接返回False
return False
# 测试代码
if __name__ == '__main__':
list1 = SingleLinkList()
print(list1.is_empty())
list1.add('a')
list1.add('b')
list1.add('c')
list1.add('d')
list1.travel()
print(list1.search('d'))
双向链表
双向链表是一种更为复杂的链表。每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。
常用操作(常用方法)
和上面两个链表没什么区别。还是那几个方法:判断空表、计算长度、表头(表中、表尾)插入、删除、遍历、检索。
# 双向链表
class DoubleNode:
"""双向链表的节点"""
"""
和单向(循环)链表不同的地方在于,
由于双向链表的每个链接都有两个链接,
所以需要存储两个节点,prev和next,
分别代表指向前一个节点和指向后一个节点。
"""
def __init__(self,item):
"""初始化节点"""
self.item = item
self.prev = None
self.next = None
class DoubleLinkList:
"""双向链表"""
def __init__(self):
# 初始化头节点
self.__head = None
def is_empty(self):
# 判断空表
return self.__head == None
def length(self):
# 计算长度
# 如果是空链表,调用判断空表的方法
if self.is_empty():
return 0
cur = self.__head # 设置临时节点
count = 0 # 设置计数值
# 当临时节点位于非空节点上时,计数+1,cur向下移动
while cur != None:
count += 1
cur = cur.next
# 返回计数
return count
def travel(self):
"""遍历"""
# 判断为空在遍历里可要可不要,无影响
# if self.is_empty():
# return 0
# 建立临时节点
cur = self.__head
# 遍历,输出,cur往下移动
while cur != None:
print(cur.item)
cur = cur.next
def search(self,item):
"""搜索"""
# 判断空表
if self.is_empty():
return 0
# 建立临时节点
cur = self.__head
# 临时节点所在位置的item区域正好是用户输入的item参数时
if cur.item == item:
return True
# 如果不是,开始遍历
while cur != None:
# 同上
if cur.item == item:
return True
# 没找到就cur向下移动
cur = cur.next
# 遍历结束还没找到就返回False
return False
def add(self,item):
# 生成一个节点
node = DoubleNode(item)
# 链表为空的情况
if self.is_empty():
# 直接将node插入头节点位置
self.__head = node
else:
# 将node的next指向原来的头节点
node.next = self.__head
# 将原来头节点的前一个节点设置为当前的node
self.__head.prev = node
# 头节点指向node
self.__head = node
def append(self,item):
"""尾部添加"""
node = DoubleNode(item)
if self.is_empty():
# 链表为空的情况
self.__head = node
else:
cur = self.__head
while cur.next != None:
cur = cur.next
# 原来尾节点的next 指向了新节点
cur.next = node
# 新节点的prev指向cur
node.prev = cur
def insert(self,pos,item):
"""指定位置添加"""
# 指定的位置小于等于0时调用add方法
if pos <= 0:
self.add(item)
# 指定的位置大于最大长度-1,这是因为链表也遵守从0开始计数的原则
if pos > self.length() - 1:
# 此时pos指向最后一个节点,调用append方法
self.append(item)
else:
# 准备参数item
node = DoubleNode(item)
# count计数
count = 0
# 临时节点cur
cur = self.__head
# 遍历到(pos-1)位置
while count < pos - 1:
count += 1
cur = cur.next
# node的prev指向cur
node.prev = cur
# node的next指向cur的下一个节点
node.next = cur.next
# cur的下一个节点的prev指向node
cur.next.prev = node
# cur的next指向node
cur.next = node
def remove(self,item):
"""删除元素"""
# 临时节点
cur = self.__head
# 遍历节点
while cur != None:
# 找到节点
if cur.item == item:
# 临时节点在头部
if cur == self.__head:
# 头节点向下移动,原头节点消失
self.__head = cur.next
# 如果不止一个节点
if cur.next:
# 临时节点的下一个节点的prev指向None
cur.next.prev = None
# 如果不是在头节点
else:
# cur前一个节点的next指向cur的下一个节点,即cur指向的节点消失
cur.prev.next = cur.next
# 如果cur的下一个节点存在
if cur.next:
# cur的下一个节点的prev指向cur的前一个节点
cur.next.prev = cur.prev
# 记得要退出循环
break
# 如果while循环没有找到节点
else:
# 向下遍历
cur = cur.next
if __name__ == '__main__':
L2 = DoubleLinkList()
L2.travel()
L2.add("haha")
L2.add(5)
L2.add(4)
L2.append(2)
L2.travel()
print(L2.length())
print(L2.search('haha'))
L2.insert(1,"heihei")
print('---------------------')
L2.travel()
print('---------------------')
L2.remove(3)
L2.travel()