链表

链表

链表和顺序表统称为线性表

链表把数据分为两部分，一部分是数据区，一部分是链接区

单向链表

class Node(object):
‘’‘节点’’’
def init(self,element):
self.elem=element
self.next=None

#用元组(elem,None)也可以保存数据
#node=Node(100)
class SingleLinkList(object):
‘’‘单链表’’’
def init(self,node=None):
self.__head=node
def is_empty(self):
‘’‘链表是否为空’’’
return self.__head == None
def length(self):
‘’‘链表长度’’’
#cur游标，用来移动遍历节点
cur=self.__head
#count记录数量
count=0
while cur!=None:
count+=1
cur=cur.next
return count

def travel(self):
	'''遍历整个链表'''
	cur=self.__head
	while cur!=None:
		print(cur.elem,end=' ')
		cur=cur.next
	print('')

def add(self,item):
	'''链表头部添加元素,头插法'''
	node=Node(item)
	node.next=self.__head
	self.__head=node
	#时间复杂度O(1)

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
	#时间复杂度O(n)

def insert(self,pos,item):
	'''指定位置添加节点'''
	#pos从0开始，起始值是0
	if pos<=0:
		self.add(item)
	elif pos>(self.length()-1):
		self.append(item)
	else:
		pre=self.__head
		count=0
		while count<(pos-1):
			count+=1
			pre=pre.next
		#循环退出后，pre指向pos-1位置
		node=Node(item)
		node.next=pre.next
		pre.next=node
	#时间复杂度O(n)

def remove(self,item):
	'''删除节点'''
	#空链表、首节点
	cur=self.__head
	pre=None
	while cur != None:
		if cur.elem == item:
			#先判断此节点是否是头节点
			if cur==self.__head:
				self.__head=cur.next
			else:
				pre.next=cur.next
			break
		else:
			pre=cur
			cur=cur.next

def search(self,item):
	'''查找节点是否存在'''
	cur=self.__head
	while cur != None:
		if cur.elem==item:
			return True
		else:
			cur=cur.next
	return False
#时间复杂度O(n)

顺序表的优点是在存取元素的时候可以通过O(1)一次性定位，但是他的缺点在于对于顺序表她的空间必须是连续的，当发生改变的时候整个存储区都得改变，如果没有这么大的连续的存储区的时候，顺序表就得换成链表了，他可以利用分散的存储空间，但是他的缺点是需要额外的地址空间next，而且只能从头往后遍历，时间复杂度为O(n)。没有办法达到O(1)。

单向循环链表

class Node(object):
‘’‘节点’’’
def init(self,element):
self.elem=element
self.next=None

#用元组(elem,None)也可以保存数据
#node=Node(100)
class SingleCycleLinkList(object):
‘’‘单向循环链表’’’
def init(self,node=None):
self.__head=node
if node:
node.next=node
def is_empty(self):
‘’‘链表是否为空’’’
return self.__head == None
def length(self):
‘’‘链表长度’’’
#cur游标，用来移动遍历节点
if self.is_empty():
return 0
cur=self.__head
#count记录数量
count=1
while cur.next!= self.__head:
count+=1
cur=cur.next
return count

def travel(self):
	'''遍历整个链表'''
	if self.is_empty():
		return
	cur=self.__head
	while cur.next!=self.__head:
		print(cur.elem,end=' ')
		cur=cur.next
		#退出循环,cur指向尾节点,但尾节点未打印出来
	print(cur.elem)
	
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=self.__head
	#时间复杂度O(1)

def append(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
		node.next=self.__head
		cur.next=node
	#时间复杂度O(n)

def insert(self,pos,item):
	'''指定位置添加节点'''
	#pos从0开始，起始值是0
	if pos<=0:
		self.add(item)
	elif pos>(self.length()-1):
		self.append(item)
	else:
		pre=self.__head
		count=0
		while count<(pos-1):
			count+=1
			pre=pre.next
		#循环退出后，pre指向pos-1位置
		node=Node(item)
		node.next=pre.next
		pre.next=node
	#时间复杂度O(n)

def remove(self,item):
	'''删除节点'''
	#空链表、首节点
	if self.is_empty():
		return
	cur=self.__head
	pre=None
	while cur.next != self.__head:
		if cur.elem == item:
			#先判断此节点是否是头节点
			#找尾节点
			if cur==self.__head:
				rear=self.__head
				while rear.next!=self.__head:
					rear=rear.next
				self.__head=cur.next
				rear.next=self.__head
			else:
			#中间节点
				pre.next=cur.next
			return
		else:
			pre=cur
			cur=cur.next
	#退出循环，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
	cur=self.__head
	while cur.next!=self.__head:
		if cur.elem == item:
			return True
		else:
			cur=cur.next
	#退出循环，cur指向尾节点
	if cur.elem == item:
		return True
	return False
#时间复杂度O(n)

双向链表

class Node(object):
‘’‘结点’’’
def init(self,item):
self.elem=item
self.next=None
self.prev=None

class DoubleLinkList(object):
def init(self,node=None):
self.__head=node
def is_empty(self):
‘’‘链表是否为空’’’
return self.__head == None
def length(self):
‘’‘链表长度’’’
#cur游标，用来移动遍历节点
cur=self.__head
#count记录数量
count=0
while cur!=None:
count+=1
cur=cur.next
return count

def travel(self):
	'''遍历整个链表'''
	cur=self.__head
	while cur!=None:
		print(cur.elem,end=' ')
		cur=cur.next
	print('')

def add(self,item):
	'''链表头部添加节点,头插法'''
	node=Node(item)
	if self.is_empty():
		self.__head=node
	else:
		node.next=self.__head
		self.__head=node
		node.next.prev=node
	#时间复杂度O(1)

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.prev=cur
	#时间复杂度O(n)

def insert(self,pos,item):
	'''指定位置添加节点'''
	#pos从0开始，起始值是0
	if pos<=0:
		self.add(item)
	elif pos>(self.length()-1):
		self.append(item)
	else:
		cur=self.__head
		count=0
		while count<pos:
			count+=1
			cur=cur.next
		#循环退出后，cur指向pos位置
		node=Node(item)
		node.next=cur
		node.prev=cur.prev
		cur.prev.next=node
		cur.prev=node
		
	#时间复杂度O(n)

def remove(self,item):
	'''删除节点'''
	#空链表、首节点
	cur=self.__head
	while cur != None:
		if cur.elem == item:
			#先判断此节点是否是头节点
			if cur==self.__head:
				self.__head=cur.next
				if cur.next:
					#判断链表是否只有一个节点
					cur.next.prev=None
			else:
				cur.prev.next=cur.next
				if cur.next:
					cur.next.prev=cur.prev
			break
		else:
			cur=cur.next

def search(self,item):
	'''查找节点是否存在'''
	cur=self.__head
	while cur != None:
		if cur.elem==item:
			return True
		else:
			cur=cur.next
	return False
#时间复杂度O(n)