1.单向链表:(10/31增加根据索引删除结点,删除头结点额尾部结点)
#1.单向链表:
class SingleNode():
def __init__(self, item):
'''单向链表的结点实现'''
self.item = item # item 存放数据
self.next = None
#单链表的操作: 增删改查
# is_empty() 链表是否为空
# length() 链表长度
# show() 遍历整个链表
# add(item) 链表头部添加元素
# append(item) 链表尾部添加元素
# insert(pos, item) 指定位置添加元素
# remove(item) 删除节点
# search(item) 查找节点是否存在
#remove_index(index)根据索引删除结点
#remove_head()删除头部结点
#remove_tail()删除尾部结点
class SingleLinkList():
'''单向链表的实现'''
def __init__(self):
self._head = None
def is_empty(self):
return self._head == None
def length(self):
cur = self._head
count = 0
while cur != None: #xi此处错误写成 if
count += 1
cur = cur.next
return count
def show(self):
'''遍历列表数据'''
list = []
cur = self._head
while cur != None:
list.append(cur.item)
cur = cur.next
print(list)
def add(self, item):
'''在单向链表的头部增加元素'''
node = SingleNode(item)
node.next = self._head
self._head = node
def append(self, item):
'''在尾部添加数据:
1.判断结点是否为空:如是增加即可
2.不为空:1。找到尾部结点;2,增加结点
'''
node = SingleNode(item)
if self.is_empty():
self._head = node
else:
cur = self._head
while cur.next is not None:
cur = cur.next
cur.next = node
def insert(self, pos , item):
'''在指定位置添加数据:
1.判断结点是否为空:如是增加即可
2.不为空:1。找到尾部结点;2,增加结点
'''
node = SingleNode(item)
if pos <= 0:
self.add(item)
elif pos > (self.length()-1):
self.append(item)
else:
count = 0
pre = self._head
while count < (pos-1):
count += 1
pre = pre.next
node.next = pre.next
pre.next = node
def remove(self, item):
cur = self._head
pre = None
while cur != None:
if cur.item == item:
if not pre:
self._head = cur.next
else:
pre.next = cur.next
break
else:
pre = cur
cur = cur.next
def remove_head(self):
#移除头部结点
self._head = self._head.next
def remove_index(self, index):
#依据索引移除结点
cur = self._head
pre = None
count = 0
while cur is not None:
if count == index:
if not pre:
self._head = cur.next
else:
pre.next = cur.next
count += 1
pre = cur
cur = cur.next
def remove_tail(self):
#删除尾部结点
print(self._head.next.item)
cur = self._head
pre = None
while cur.next is not None:
pre = cur
cur = cur.next
pre.next = None
def reseach(self, item):
'''在单向链表的查找元素,如存在返回True,不存在返回False'''
cur = self._head
while cur is not None:
if cur.item == item:
return True
cur = cur.next
return False
s = SingleLinkList()
s.append(12)
s.append(100)
s.show()
print(s.length())
s.insert(1, 222)
s.remove(100)
s.show()
# [12, 100]
# 2
# [12, 222]
s.add(11)
s.show() # [11, 12, 222]
print(s.reseach(12)) # True
2.单向循环列表:
单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点。
#coding=gbk
#单向循环链表
# 单链表的一个变形是单向循环链表,链表中最后一个节点的next域不再为None,而是指向链表的头节点。
from platform import node
class Node():
'''定义结点'''
def __init__(self, item):
self.item = item
self.next = None
# is_empty() 判断链表是否为空
# length() 返回链表的长度
# show() 遍历
# add(item) 在头部添加一个节点
# append(item) 在尾部添加一个节点
# insert(pos, item) 在指定位置pos添加节点
# remove(item) 删除一个节点
# search(item) 查找节点是否存在
class SinCycLinkedList():
def __init__(self):
self._head = None
def is_empty(self):
return self._head == None
def length(self):
'''获取单向循环链表的长度'''
if self.is_empty():
return 0
count = 1 # 当 cur.next == self._head 时,表示已经有了一个结点
cur = self._head
while cur.next != self._head: #不同于普通的单向链表的判断条件: while cur.next != None:
count += 1
cur = cur.next
return count
def show(self):
'''获取单向循环链表的数据'''
if self.is_empty():
return
li = []
cur = self._head
li.append(cur.item)
while cur.next != self._head:
cur = cur.next
li.append(cur.item)
print(li)
def add(self, item):
'''添加头结点'''
node = Node(item)
if self.is_empty():
self._head = node
node.next = self._head
else:
node.next = self._head #如果不为空的话:1.将node.next 指向 头结点
cur = self._head
while cur.next != self._head: # 2.找到尾结点
cur = cur.next
cur.next = node # 3. node作为头结点,连接头结点
self._head = node #4. 复原头结点
def append(self, item):
'''在尾部添加结点'''
node = Node(item)
if self.is_empty():
self._head = node
node.next = self._head
else:
cur = self._head
while cur.next != self._head: # 首先找到尾结点
cur = cur.next
cur.next = node # 尾结点的 next 指向 node
node.next = self._head #构成循环
def insert(self, pos, item):
'''在指定位置中增加结点'''
if pos <= 0:
self.add(item)
elif pos > (self.length() - 1):
self.append(item)
else:
node = Node(item)
cur = self._head # 当pos为 1时的情况,不执行while语句
count = 0
while count < (pos-1): # 当 pos 大于1 的情况,移动到指定位置的前一位置(pos - 1)
count += 1
cur = cur.next
node.next = cur.next
cur.next = node
def remove(self, item):
'''依据数据值, 删除一个结点'''
if self.is_empty():
return
cur = self._head
pre = None
if cur.item == item: #大的判断条件:是否头结点是要删除的元素
if cur.next != self._head: #如果还有多个结点
while cur.next != self._head: # 先找到尾结点
cur = cur.next
cur.next = self._head.next
self._head = self._head.next
else:
self._head = None #如果只有1个结点, 则全部删除
else: #如果不是要删除头结点
pre = self._head
while cur.next != self._head:
if cur.item == item:
pre.next = cur.next
return
else:
pre = cur
cur = cur.next
if cur.item == item: #如果恰好是尾结点
pre.next = cur.next
print('输入的数值错误')
def search(self, item):
if self.is_empty():
return False
cur = self._head
if cur.item == item:
return True
while cur.next != self._head:
cur = cur.next
if cur.item == item:
return True
return False
print('test------')
s = SinCycLinkedList()
s.add(10)
s.add(11)
s.show() # [11, 10]
print(s.is_empty()) #False
print(s.length()) # 2
s.append(12)
s.append(13)
s.show() # [11, 10, 12, 13]
print(s.length()) # 4
s.insert(1, 100)
s.show() # [11, 100, 10, 12, 13]
print(s.search(12)) #True
print(s.search(20)) #False
s.remove(101) #输入的数值错误
s.show() #[11, 100, 10, 12, 13]
s.remove(11)
s.show() #[100, 10, 12, 13]
3.双向链表:(增加插入的结点图片解释)
每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。
#coding=gbk
#双向链表
#每个节点有两个链接:一个指向前一个节点,当此节点为第一个节点时,指向空值;而另一个指向下一个节点,当此节点为最后一个节点时,指向空值。
class Node():
def __init__(self, item):
self.item = item
self.next = None
self.pre = None
#操作
# is_empty() 链表是否为空
# length() 链表长度
# show() 遍历链表
# add(item) 链表头部添加
# append(item) 链表尾部添加
# insert(pos, item) 指定位置添加
# remove(item) 删除节点
# search(item) 查找节点是否存在
class DLinkList():
def __init__(self):
self._head = None
def is_empty(self):
return self._head == None
def length(self):
cur = self._head
count = 0
while cur != None:
count += 1
cur = cur.next
return count
def show(self):
cur = self._head
li = []
while cur != None:
li.append(cur.item)
cur = cur.next
print(li)
def search(self, item):
if self.is_empty():
return False
else:
cur = self._head
while cur != None:
if cur.item == item:
return True
cur = cur.next
return False
def add(self, item):
'''在双向链表的头增加结点'''
node = Node(item)
if self.is_empty():
self._head = node
else:
node.next = self._head
self._head.pre = node #将_head 的pre 指向node
self._head = node
def append(self, item):
'''在双向链表的尾部增加结点'''
node = Node(item)
if self.is_empty():
self._head = node
else:
cur = self._head
while cur.next != None:
cur = cur.next
cur.next = node
node.pre = cur
def insert(self, pos, item):
'''在双向链表的指定位置增加结点'''
if pos <= 0:
self.add(item)
elif pos >(self.length() - 1):
self.append(item)
else:
node = Node(item)
cur = self._head
count = 0
while count < (pos - 1):
count += 1
cur = cur.next
node.next = cur.next #4 个指针的指向
node.pre = cur
cur.next = node
cur = node
def remove(self, item):
'''删除对应元素'''
if self.is_empty():
return
else:
cur = self._head
if cur.item == item: #如果头结点就是要删除的元素
if cur.next == None: #如果只有一个结点
self._head = None
else:
cur.next.pre = None
self._head = cur.next
return
# 如果不是头结点时要删除的元素
while cur != None:
if cur.item == item:
cur.pre.next = cur.next #需要变换 2 个指向
cur.next.pre = cur.pre
return
cur = cur.next
print('test ===')
d = DLinkList()
d.add(11)
d.add(12)
d.show() # [12, 11]
print(d.length()) #2
print(d.is_empty())#False
d.append(13)
d.append(14)
d.show() # [12, 11, 13, 14]
print(d.search(11)) #True
print(d.search(18)) #False
d.insert(1, 100)
d.show() # [12, 100, 11, 13, 14]
d.remove(11)
d.show() #[12, 100, 13, 14]
# for i in range(10):
# print(i)
# return
# i = 0
# while i<10:
# i += 1
# if i == 5:
# break
# print(i)
# for k in range(1):
# print('kkkkkk')
其中,插入元素中:
node.next = cur.next #4 个指针的指向
node.pre = cur
cur.next = node
cur = node