#双向链表
- 每个节点都有一个直接前驱和直接后继
- 从链表的任意位置节点开始都可以访问其前驱节点和后继节点
#双向链表的实现 - 创建链表的内部节点类，存放节点的元素与指针
class Node :
def __init__(self,data,next = None,prev = None):
""""
:param data:节点的元素域
:param next: 节点的后继
:param prev:：节点的前驱
"""
self.data = data
self.next = next
self.prev = prev
- 初始化头节点
def __init__(self,node= None):
"""
:param node:头节点
"""
self.head = node #初始化节点为空
self._size = 0 #初始化链表的长度
- length()
- is_empty()
def length(self): #双向链表的长度
return self._size
def is_empty(self):
return self._size == 0
- 获取链表中的节点元素
def get_list(self): #获取整个链表
if not self.is_empty() :
cur = self.head
while cur : #遍历整个链表，依次取出节点中的元素
print(cur.data,end=" ")
cur = cur.next
return False
def get_index(self,pros): #依照索引获取节点
if not self.is_empty() :
count ,cur = 0,self.head
while count < pros :
cur = cur.next
return cur.data
return False
- 添加节点
def add_first(self,element):
'''
向链表中的头部添加节点
链表为空：设置新节点前驱和后继为空>_head赋给新节点
链表非空 ：设置新节点的前驱为None,后继指向_head，_head的前驱指向新节点>_head赋给新节点
'''
node = self.Node(element)
node.prev = None
node.next = None
if not self.is_empty() :
node.next = self.head
self.head.prev = node
self.head = node #把node的值赋给self.head
self._size += 1
def add_last(self,elemnet): #向链表的最后添加元素
node = self.Node(elemnet)
if self.is_empty() :
self.add_first(elemnet)
else :
'''
遍历到链表的最后一个节点 > 新节点的前驱指向最后一个节点 > 新节点的后继为None > 最后一个节点的后继指向新节点
'''
cur = self.head
while cur.next != None :
cur = cur.next
node.next = None
node.prev = cur
cur.next = node
self._size += 1
def insert_element(self,index,element):
node = self.Node(element)
if not self.is_empty() or index <0 or index >self._size :
count, cur = 0, self.head
if index == 0:
self.add_first(element)
while count < index:
'''
遍历到指定索引的节点 > 新节点的前驱指向该节点 > 新节点的后继指向该节点的后继 > _head赋给新节点
'''
if count == index - 1:
node.prev = cur
node.next = cur.next
cur.next = node
break
cur = cur.next
count += 1
self._size += 1
return False
- 删除节点
def del_first(self): #删除头部节点
if not self.is_empty() :
'''
把头节点的后继赋给_head
'''
cur = self.head
self.head = cur.next
self._size -= 1
return False
def del_last(self): #删除尾部节点
if not self.is_empty() :
'''
遍历到尾部节点的直接前驱 > 直接前驱的直接后继指向None
'''
cur = self.head
while cur.next.next != None :
cur = cur.next
cur.next = None
self._size -= 1
return False
def del_insert(self,pros): #删除指定索引的节点
if not self.is_empty() or pros < 0 or pros > self._size :
if pros == 0 :
self.del_first()
else :
count,cur = 0,self.head
while count < pros :
cur = cur.next
count += 1
'''
遍历到指定的索引的节点 > 把该节点的直接后继赋值给该节点的前驱节点的后继节点 > 把该节点的直接前驱赋值给该节点的后继节点的前驱节点
'''
cur.prev.next = cur.next
cur.next.prev = cur.prev
self._size -= 1
return False
def del_all(self):
if self.is_empty() :
return True
else : #优化
cur = self.head
while cur :
self.head = None
cur = cur.next
self._size = 0
- 修改节点
def change(self,pros,element):
if self.is_empty() :
return False
else :
'''
遍历到指定的节点，将新元素赋值给该节点
'''
count,cur = 0,self.head
while count < pros :
cur = cur.next
count += 1
cur.data = element