python 链表

链表是由一系列节点组成的元素集合，每个节点包含两部分，数据域item和指向下一个节点的指针next。通过节点之间的相互连接，最终串联成一个链表

箭头就是指向

item 是存的几就是几
next 这个节点的下一个节点是谁(指向下一个节点)

头插发

3要成为新的头

尾插法

class Node:
	def __init__(self,item):
		self.item = item
		self.next = None

a = Node(1)
b = Node(2)
c = Node(3)
#怎么把他们链接起来呢 
a.next = b
b.next = c 

只需要通过a的节点,就能找到c

class Node:
    def __init__(self, item):
        #数据域item 头是几
        self.item = item
        #下一个节点指针
        self.next = None

#头结点
def create_linklist_head(li):
    #头结点
    head = Node(li[0])
    #从1开始,0已经有了
    for element in li[1:]:
        #创建新节点
        node = Node(element)
        #新的节点链接指向
        node.next = head
        #head重新复制指向它
        head = node
    return head

#尾插法
def create_linklist_tail(li):
#创建第一个节点
    head = Node(li[0])
    #同时有头和尾都指向它
    tail = head
    for element in li[1:]:
    	#创建新节点
        node = Node(element)
        tail.next = node
        #新的node 称为最后一个
        tail = node
    return head

def print_linklist(lk):
    while lk:
        print(lk.item, end=',')
        lk = lk.next

lk = create_linklist_head([1,2,3,6,8])
# print(lk.next.item)
# print(lk.item)
#lk = create_linklist_tail([1,2,3,6,8])
print_linklist(lk)

头

尾

单向循环链表

如果只有一个结点,node.next指向的是它自己

长度 

append的方法

  就是下面的图片 
  #新结点指向头
  node.next = self.__head
  #原最后一个结点。指向新节点
  cur.next = node

#头插法

#删除

#单链表链表  从左往右读
class Node(object):
	"""双向链表节点"""
	def __init__(self,item):
		#数据区
		self.elem = item
		#指向后一个节点
		self.next = None
#单链表循环
class LinkList(object):
	def __init__(self,node=None):
		#代表头节点
		self.__head = node
		#特殊处理回环 如果只有要给结点,node.next指向的是它自己 
		if node:
			node.next = node 

	#判断链表是否为空
	def is_empty(self):
		return self.__head == None

	def length(self):
		"""返回链表的长度"""
		if self.is_empty():
			return 0 

		else:

			#cur游标移动 count从1开始
			cur = self.__head
			#count用来计数
			count = 1
			while cur != self.__head:
				count += 1
				#让cur游标可以向下移动
				cur = cur.next
			return count
	
	#遍历整个链表
	def travel(self):
		if self.is_empty():
			return
		#建立游标等于起始节点
		else:
			cur = self.__head
			while cur.next != self.__head:
				print(cur.elem,end=" ")
				cur = cur.next
			#退出循环,cur指向了尾结点
			print(cur.elem,end=' ')
			#换行
			print("")

	#头插法
	def add(self,item):
		#新节点
		node = Node(item)
		if self.is_empty():
			#特殊处理只有一个节点的时候
			self.__head = node
			node.next = node
		else:
			#游标
			cur = self.__head 
			while cur.next != self.__head:
				cur = cur.next
			#退出来就是cur 停留在最后的位置 
			node.next = self.__head
			self.__head = node 
			#最后一个指向新的 形成回环
			cur.next = node
	

	def append(self,item):
		"""链表尾部添加元素"""
		node = Node(item)  #定义新节点
		#链表是否为空链表
		if self.is_empty():
			#如果为空，新的节点加了进去
			self.__head = node
			#处理特殊 为空是第一个结点 node.next =它自己(node)
			node.next = node 
		else:
			#头节点 创建游标
			cur = self.__head   #设置指向头结点的游标  此时的当前链表第一个节点，就是头节点指向的节点
			#cur到最后一个节点停下
			while cur.next != self.__head:
				cur = cur.next
			#cur 此时在最后一个位置 
			#新结点指向头
			node.next = self.__head
			#原最后一个结点。指向新节点
			cur.next = node
	
	#插入法  #pos从零开始
	def insert(self,pos,item):
		"""在指定位置添加元素"""
		#指向不是头部元素，self.__head的地址
		# 为下一个元素，所以pre为下一个元素
		if pos <= 0:
			#认为是头插法
			self.add(item)
		#假如长度是3 pos大于2要特殊处理  
		elif pos > (self.length()-1):
			#尾插法
			self.append(item)
		else:
			cur = self.__head
			count = 0
			while count < pos:
				count+=1
				cur = cur.next
			#新节点
			node = Node(item)
			#把节点链接到中间任意位置 插入前一个节点
			node.next = cur
			node.prev = cur.prev
			cur.prev.next = node
			cur.prev = node

	#删除有3个游标
	def remove(self,item):
		"""删除元素"""
		if self.is_empty():
			return

		else:
			cur = self.__head
			pur = None
			while cur.next != self.__head:
				#判断cur的数据是否为要删除的数据 
				if cur.elem == item:
					
					#判断此节点是否为头节点
					#是头节点  现在是删除第一个节点
					if cur == self.__head:
						#考虑回环，还需要要给游标拿到尾节点位置 
						#删除第一个节点
						#游标 这里直接将rear移动到最后即可 考虑回环 还需要一个游标拿到尾节点位置 还是先等于头
						rear = self.__head  
						while rear.next != self.__head:
							rear = rear.next
						#退出循环 此时 rear指向最后一个节点了
						self.__head = cur.next
						#回环
						rear.next = self.__head
						if cur.next != None:
							#是否只有一个节点
							cur.next.prev = None
					else:
						#其他的节点 
						pre.next = cur.next
					return	
				else:
					#移动游标 pre 先动  cur后动 
					pre = cur
					#cur游标向下移动
					cur = cur.next
			#退出循环时候 cur指向最后一个节点    如果当前cur指向的节点等于要删除的 
			if cur.elem == item:
				#考虑只有一个节点
				if cur == self.__head:
					self.__head = None
				else:
					pre.next = cur.next

	#查找别丢下最后要给
	def search(self,item):
		"""查找结点是否存在"""
		#如果是一个空链表
		if self.is_empty():
			return False

		else:
			cur = self.__head
			while cur.next != self.__head:
				#cur数据是否为查找的数据 item是要查的数据 
				if cur.elem == item:
					return True
				else:
					cur = cur.next
			#处理最后一个节点 当前停留的元素
			if cur.elem == item:
				return True
			#遍历完成 
			return False

if __name__ == '__main__':
	ll = LinkList()
	#第一次的
	print(ll.is_empty())
	print(ll.length())
	print("----------------------------------")
	ll.travel()
	ll.append(1)
	print(ll.is_empty())
	print(ll.length())
	
	ll.append(2)	
	ll.append(3)
	ll.append(4)
	ll.append(5)
	ll.travel()
	ll.remove(2)
	ll.travel()
	ll.remove(4)
	ll.travel()