In diesem Artikel werden hauptsächlich relevante Informationen zum Python-Beispielcode zum Implementieren der verknüpften Liste vorgestellt. Freunde, die ihn benötigen, können sich auf
Python-Beispielcode zum Implementieren der verknüpften Liste beziehen
Vorwort
Algorithmen und Datenstrukturen sind ein immerwährendes Thema. Als Programmierer ist es sehr, sehr wichtig, die Implementierung häufig verwendeter Datenstrukturen zu beherrschen.
Implementierungsliste
Die Implementierung einer verknüpften Liste ist im Wesentlichen sprachunabhängig. Aber Flexibilität hängt eng mit der Sprache zusammen, die sie implementiert. Heute werde ich Python verwenden, um es zu implementieren, einschließlich der folgenden Vorgänge:
['addNode(self, data)'] ['append(self, value)'] ['prepend(self, value)'] ['insert(self, index, value)'] ['delNode(self, index)'] ['delValue(self, value)'] ['isempty(self)'] ['truncate(self)'] ['getvalue(self, index)'] ['peek(self)'] ['pop(self)'] ['reverse(self)'] ['delDuplecate(self)'] ['updateNode(self, index, value)'] ['size(self)'] ['print(self)']
Das Generieren einer solchen Methodenliste darf nicht manuell geschrieben werden, da es sonst sehr mühsam wird. Deshalb habe ich ein entsprechendes Programm geschrieben um es selbst umzusetzen. Der Code ist relativ einfach. Die Kernidee besteht darin, jede Zeile der Quelldatei abzugleichen, Inhalte zu finden, die den Übereinstimmungsregeln entsprechen, und sie zum Gesamtergebnissatz hinzuzufügen.
Der Code lautet wie folgt:
# coding: utf8
# @Author: 郭 璞
# @File: getmethods.py
# @Time: 2017/4/5
# @Contact: 1064319632@qq.com
# @blog: http://blog.csdn.net/marksinoberg
# @Description: 获取一个模块或者类中的所有方法及参数列表
import re
def parse(filepath, repattern):
with open(filepath, 'rb') as f:
lines = f.readlines()
# 预解析正则
rep = re.compile(repattern)
# 创建保存方法和参数列表的结果集列表
result = []
# 开始正式的匹配实现
for line in lines:
res = re.findall(rep, str(line))
print("{}的匹配结果{}".format(str(line), res))
if len(res)!=0 or res is not None:
result.append(res)
else:
continue
return [item for item in result if item !=[]]
if __name__ == '__main__':
repattern = "def (.[^_0-9]+\(.*?\)):"
filepath = './SingleChain.py'
result = parse(filepath, repattern)
for item in result:
print(str(item))Implementierung verknüpfter Listen
# coding: utf8
# @Author: 郭 璞
# @File: SingleChain.py
# @Time: 2017/4/5
# @Contact: 1064319632@qq.com
# @blog: http://blog.csdn.net/marksinoberg
# @Description: 单链表实现
class Node(object):
def __init__(self, data, next):
self.data = data
self.next = next
class LianBiao(object):
def __init__(self):
self.root = None
# 给单链表添加元素节点
def addNode(self, data):
if self.root==None:
self.root = Node(data=data, next=None)
return self.root
else:
# 有头结点，则需要遍历到尾部节点，进行链表增加操作
cursor = self.root
while cursor.next!= None:
cursor = cursor.next
cursor.next = Node(data=data, next=None)
return self.root
# 在链表的尾部添加新节点，底层调用addNode方法即可
def append(self, value):
self.addNode(data=value)
# 在链表首部添加节点
def prepend(self, value):
if self.root == None:
self.root = Node(value, None)
else:
newroot = Node(value, None)
# 更新root索引
newroot.next = self.root
self.root = newroot
# 在链表的指定位置添加节点
def insert(self, index, value):
if self.root == None:
return
if index<=0 or index >self.size():
print('index %d 非法， 应该审视一下您的插入节点在整个链表的位置！')
return
elif index==1:
# 如果index==1， 则在链表首部添加即可
self.prepend(value)
elif index == self.size()+1:
# 如果index正好比当前链表长度大一，则添加在尾部即可
self.append(value)
else:
# 如此，在链表中部添加新节点，直接进行添加即可。需要使用计数器来维护插入未知
counter = 2
pre = self.root
cursor = self.root.next
while cursor!=None:
if counter == index:
temp = Node(value, None)
pre.next = temp
temp.next = cursor
break
else:
counter += 1
pre = cursor
cursor = cursor.next
# 删除指定位置上的节点
def delNode(self, index):
if self.root == None:
return
if index<=0 or index > self.size():
return
# 对第一个位置需要小心处理
if index == 1:
self.root = self.root.next
else:
pre = self.root
cursor = pre.next
counter = 2
while cursor!= None:
if index == counter:
print('can be here!')
pre.next = cursor.next
break
else:
pre = cursor
cursor = cursor.next
counter += 1
# 删除值为value的链表节点元素
def delValue(self, value):
if self.root == None:
return
# 对第一个位置需要小心处理
if self.root.data == value:
self.root = self.root.next
else:
pre = self.root
cursor = pre.next
while cursor!=None:
if cursor.data == value:
pre.next = cursor.next
# 千万记得更新这个节点，否则会出现死循环。。。
cursor = cursor.next
continue
else:
pre = cursor
cursor = cursor.next
# 判断链表是否为空
def isempty(self):
if self.root == None or self.size()==0:
return True
else:
return False
# 删除链表及其内部所有元素
def truncate(self):
if self.root == None or self.size()==0:
return
else:
cursor = self.root
while cursor!= None:
cursor.data = None
cursor = cursor.next
self.root = None
cursor = None
# 获取指定位置的节点的值
def getvalue(self, index):
if self.root is None or self.size()==0:
print('当前链表为空！')
return None
if index<=0 or index>self.size():
print("index %d不合法！"%index)
return None
else:
counter = 1
cursor = self.root
while cursor is not None:
if index == counter:
return cursor.data
else:
counter += 1
cursor = cursor.next
# 获取链表尾部的值，且不删除该尾部节点
def peek(self):
return self.getvalue(self.size())
# 获取链表尾部节点的值，并删除该尾部节点
def pop(self):
if self.root is None or self.size()==0:
print('当前链表已经为空！')
return None
elif self.size()==1:
top = self.root.data
self.root = None
return top
else:
pre = self.root
cursor = pre.next
while cursor.next is not None:
pre = cursor
cursor = cursor.next
top = cursor.data
cursor = None
pre.next = None
return top
# 单链表逆序实现
def reverse(self):
if self.root is None:
return
if self.size()==1:
return
else:
# post = None
pre = None
cursor = self.root
while cursor is not None:
# print('逆序操作逆序操作')
post = cursor.next
cursor.next = pre
pre = cursor
cursor = post
# 千万不要忘记了把逆序后的头结点赋值给root，否则无法正确显示
self.root = pre
# 删除链表中的重复元素
def delDuplecate(self):
# 使用一个map来存放即可，类似于变形的“桶排序”
dic = {}
if self.root == None:
return
if self.size() == 1:
return
pre = self.root
cursor = pre.next
dic = {}
# 为字典赋值
temp = self.root
while temp!=None:
dic[str(temp.data)] = 0
temp = temp.next
temp = None
# 开始实施删除重复元素的操作
while cursor!=None:
if dic[str(cursor.data)] == 1:
pre.next = cursor.next
cursor = cursor.next
else:
dic[str(cursor.data)] += 1
pre = cursor
cursor = cursor.next
# 修改指定位置节点的值
def updateNode(self, index, value):
if self.root == None:
return
if index<0 or index>self.size():
return
if index == 1:
self.root.data = value
return
else:
cursor = self.root.next
counter = 2
while cursor!=None:
if counter == index:
cursor.data = value
break
cursor = cursor.next
counter += 1
# 获取单链表的大小
def size(self):
counter = 0
if self.root == None:
return counter
else:
cursor = self.root
while cursor!=None:
counter +=1
cursor = cursor.next
return counter
# 打印链表自身元素
def print(self):
if(self.root==None):
return
else:
cursor = self.root
while cursor!=None:
print(cursor.data, end='\t')
cursor = cursor.next
print()
if __name__ == '__main__':
# 创建一个链表对象
lianbiao = LianBiao()
# 判断当前链表是否为空
print("链表为空%d"%lianbiao.isempty())
# 判断当前链表是否为空
lianbiao.addNode(1)
print("链表为空%d"%lianbiao.isempty())
# 添加一些节点，方便操作
lianbiao.addNode(2)
lianbiao.addNode(3)
lianbiao.addNode(4)
lianbiao.addNode(6)
lianbiao.addNode(5)
lianbiao.addNode(6)
lianbiao.addNode(7)
lianbiao.addNode(3)
# 打印当前链表所有值
print('打印当前链表所有值')
lianbiao.print()
# 测试对链表求size的操作
print("链表的size: "+str(lianbiao.size()))
# 测试指定位置节点值的获取
print('测试指定位置节点值的获取')
print(lianbiao.getvalue(1))
print(lianbiao.getvalue(lianbiao.size()))
print(lianbiao.getvalue(7))
# 测试删除链表中指定值， 可重复性删除
print('测试删除链表中指定值， 可重复性删除')
lianbiao.delNode(4)
lianbiao.print()
lianbiao.delValue(3)
lianbiao.print()
# 去除链表中的重复元素
print('去除链表中的重复元素')
lianbiao.delDuplecate()
lianbiao.print()
# 指定位置的链表元素的更新测试
print('指定位置的链表元素的更新测试')
lianbiao.updateNode(6, 99)
lianbiao.print()
# 测试在链表首部添加节点
print('测试在链表首部添加节点')
lianbiao.prepend(77)
lianbiao.prepend(108)
lianbiao.print()
# 测试在链表尾部添加节点
print('测试在链表尾部添加节点')
lianbiao.append(99)
lianbiao.append(100)
lianbiao.print()
# 测试指定下标的插入操作
print('测试指定下标的插入操作')
lianbiao.insert(1, 10010)
lianbiao.insert(3, 333)
lianbiao.insert(lianbiao.size(), 99999)
lianbiao.print()
# 测试peek 操作
print('测试peek 操作')
print(lianbiao.peek())
lianbiao.print()
# 测试pop 操作
print('测试pop 操作')
print(lianbiao.pop())
lianbiao.print()
# 测试单链表的逆序输出
print('测试单链表的逆序输出')
lianbiao.reverse()
lianbiao.print()
# 测试链表的truncate操作
print('测试链表的truncate操作')
lianbiao.truncate()
lianbiao.print()Was ist das Ergebnis der Ausführung des Codes? Ob es unsere Anforderungen erfüllen kann, schauen wir uns die gedruckten Ergebnisse an:
D:\Software\Python3\python.exe E:/Code/Python/Python3/CommonTest/datastructor/SingleChain.py 链表为空1 链表为空0 打印当前链表所有值 1 2 3 4 6 5 6 7 3 链表的size: 9 测试指定位置节点值的获取 1 3 6 测试删除链表中指定值， 可重复性删除 can be here! 1 2 3 6 5 6 7 3 1 2 6 5 6 7 去除链表中的重复元素 1 2 6 5 7 指定位置的链表元素的更新测试 1 2 6 5 7 测试在链表首部添加节点 108 77 1 2 6 5 7 测试在链表尾部添加节点 108 77 1 2 6 5 7 99 100 测试指定下标的插入操作 10010 108 333 77 1 2 6 5 7 99 99999 100 测试peek 操作 100 10010 108 333 77 1 2 6 5 7 99 99999 100 测试pop 操作 100 10010 108 333 77 1 2 6 5 7 99 99999 测试单链表的逆序输出 99999 99 7 5 6 2 1 77 333 108 10010 测试链表的truncate操作 Process finished with exit code 0
Es erfüllt gerade noch die Zielanforderungen.
Zusammenfassung
Der heutige Inhalt ist relativ einfach und überhaupt nicht schwierig. Aber verstehen und schreiben können sind zwei verschiedene Dinge. Solchen Code zu schreiben, wenn man nichts zu tun hat, ist immer noch sehr lohnend.
Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des Codes zur Implementierung einer verknüpften Liste in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
