Python Linked List
链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。
在 C/C++ 中，通常采用“指针+结构体”来实现链表；而在 Python 中，则可以采用 “引用+类” 来实现链表。
链表（Linked List ）的定义
是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。
链表是一种很常见的数据结构，链表也是一种线性表，他不像顺序表一样连续存储，而是在每个数据节点上会存放下一个节点的地址信息，通过这样的方式把每个数据节点链接起来。
链表的结构： data 为自定义的数据，next 为下一个节点的地址。
基本元素
- 节点：每个节点有两个部分，左边称为 数值域，存放用户数据；右边部分称为 指针域，用来存放指向下一个元素的指针。
- head：head 节点永远指向第一个节点
- tail：tail 永远指向最后一个节点
- None：链表中最后一个节点的指针域为 None 值
链表种类：单向链表、单向循环链表、双向链表、双向循环链表
单向链表
单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。
节点实现
class SingleNode(object):
#单链表的节点
def __init__(self,item):
self.item = item # _item 存放数据元素
self.next = None # _next 是下一个节点的标识
#定义节点
node1 = SingleNode(1)
node2 = SingleNode(2)
node3 = SingleNode(3)
# 每个节点的关系表示出来
node1.next = node2
node2.next = node3单链表的操作
- is_empty() 链表是否为空
- length() 链表长度
- travel() 遍历整个链表
- add(item) 链表头部添加元素
- append(item) 链表尾部添加元素
- insert(pos, item) 指定位置添加元素
- remove(item) 删除节点
- search(item) 查找节点是否存在
不可以用 head 来遍历列表，否则会丢失列表的一些节点，可以使用和 head 相同类型的临时的指针变量，这个变量先初始化为链表结构的 head 指针，然后控制一个循环。
probe = head
while probe != None:
probe = probe.next单链表的实现
class SingleLinkList(object):
def __init__(self):
self.__head = None
def is_empty(self):
return seif.__head is None
def length(self):
count = 0
cur = self.__head
while cur != None:
count += 1
cur = cur.next
return count
def travel(self):
"""遍历链表"""
cur = self.__head
while cur != None:
print(cur.item, end=" ")
cur = cur.next头部添加元素
def add(self, item):
"""头部添加元素"""
node = SingleNode(item)
# 将新节点的链接域 next 指向头节点，即 _head 指向的位置
node.next = self.head.next
# 将链表的头 _head 指向新节点
self.head = node尾部添加元素
def append(self, item):
"""尾部添加元素"""
node = SingleNode(item)
# 先判断链表是否为空，若是空链表，则将_head指向新节点
if self.is_empty():
self.head = node
# 若不为空，则找到尾部，将尾节点的next指向新节点
else:
cur = self.head
while cur.next != None
cur = cur.next
cur.next = node指定位置添加元素
def insert(self, pos, item):
"""指定位置添加元素"""
# 若指定位置pos为第一个元素之前，则执行头部插入
if pos <= 0:
self add(item)
# 若指定位置超过链表尾部，则执行尾部插入
elif pos >= (self.length()-1):
self.append(item)
# 找到指定位置
else:
node = SingleNode(item)
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):
"""删除节点"""
current = self._head
pre = None
while current != None:
if current.getValue() == value:
if not pre:
self._head = current.getNext()
else:
pre.setNext(current.getNext())
break
else:
pre = current
current = current.getNext()实现 Linked List 及其各类操作方法
# 先定一个node的类
class Node(): # value + next
def __init__ (self, value = None, next = None):
self._value = value
self._next = next
def getValue(self):
return self._value
def getNext(self):
return self._next
def setValue(self,new_value):
self._value = new_value
def setNext(self,new_next):
self._next = new_next
#实现Linked List及其各类操作方法
class LinkedList():
def __init__(self): # 初始化链表为空表
self._head = Node()
self._tail = None
self._length = 0
#检测是否为空
def isEmpty(self):
return self._head == None
# add 在链表前端添加元素:O(1)
def add(self,value):
newnode = Node(value,None) #create一个node（为了插进一个链表）
newnode.setNext(self._head)
self._head = newnode
# append 在链表尾部添加元素:O(n)
def append(self,value):
newnode = Node(value)
if self.isEmpty():
self._head = newnode # 若为空表，将添加的元素设为第一个元素
else:
current = self._head
while current.getNext() != None:
current = current.getNext() #遍历链表
current.setNext(newnode) # 此时 current 为链表最后的元素
# search 检索元素是否在链表中
def search(self,value):
current=self._head
foundvalue = False
while current != None and not foundvalue:
if current.getValue() == value:
foundvalue = True
else:
current = current.getNext()
return foundvalue
# index 索引元素在链表中的位置
def index(self,value):
current = self._head
count = 0
found = None
while current != None and not found:
count += 1
if current.getValue()==value:
found = True
else:
current = current.getNext()
if found:
return count
else:
raise ValueError ('%s is not in linkedlist'%value)
# remove 删除链表中的某项元素
def remove(self,value):
current = self._head
pre = None
while current != None:
if current.getValue() == value:
if not pre:
self._head = current.getNext()
else:
pre.setNext(current.getNext())
break
else:
pre = current
current = current.getNext()
# insert 链表中插入元素
def insert(self,pos,value):
if pos <= 1:
self.add(value)
elif pos > self.size():
self.append(value)
else:
temp = Node(value)
count = 1
pre = None
current = self._head
while count < pos:
count += 1
pre = current
current = current.getNext()
pre.setNext(temp)
temp.setNext(current)LISTNODE 的 PYTHON 实现
class Node:
def __init__(self):
self.val = None
self.next = None
class Node_handle():
def __init__(self):
self.cur_node = None
# 查找
def find(self,node,num,a = 0):
while node:
if a == num:
return node
a += 1
node = node.next
# 增加
def add(self,data):
node = Node()
node.val = data
node.next = self.cur_node
self.cur_node = node
return node
# 打印
def printNode(self,node):
while node:
print ('\nnode: ', node, ' value: ', node.val, ' next: ', node.next)
node = node.next
# 删除
def delete(self,node,num,b = 1):
if num == 0:
node = node.next
return node
while node and node.next:
if num == b:
node.next = node.next.next
b += 1
node = node.next
return node
# 翻转
def reverse(self,nodelist):
list = []
while nodelist:
list.append(nodelist.val)
nodelist = nodelist.next
result = Node()
result_handle =Node_handle()
for i in list:
result = result_handle.add(i)
return result
if __name__ == "__main__":
l1 = Node()
ListNode_1 = Node_handle()
l1_list = [1, 8, 3]
for i in l1_list:
l1 = ListNode_1.add(i)
ListNode_1.printNode(l1)
l1 = ListNode_1.delete(l1,0)
ListNode_1.printNode(l1)
l1 = ListNode_1.reverse(l1)
ListNode_1.printNode(l1)
l1 = ListNode_1.find(l1,1)
ListNode_1.printNode(l1)
