算法 Part2 LL Stack

知识点

1. 链表，将元素放在将通过链接构造起来的一系列存储块中，是一种线性表。
2. 链表的结构图示:
   
3. 单链表。

class Node:
	def __init__(self,elem):
		self.elem = elem
		self.next = None
class SingleLinklist:
	def __init__(self,node):
		self._head = node
	
	def is_empty(self):
		return not self._head
	
	def length(self):
		cnt,cur = 0,self._head
		while cur：
			cnt += 1
			cur = cur.next
		return cnt 
	
	def append(self,item):
		if not self._head:
			return Node(item)
		cur = self._head
		while cur.next:
			cur = cur.next
		cur.next = Node(item)
	
	def insert(self,pos,item):
		if pos <= 0:
			node = Node(item)
			node.next = self._head
			self._head = node
		cur = self._head
		cnt = 0
		while cnt<pos-1:
			if not cur.next:
				node = Node(item)
				node.next,cur.next = None,node
				return 
			cur = cur.next
			cnt += 1
		node = Node(item)
		node.next,cur.next = cur.next,node
	
	def remove(self,item):
		cur = self._head
		if cur.elem == item:
			cur = cur.next
		while cur and cur.next:
			if cur.next.elem == item:
				cur.next = cur.next.next
				break
			cur = cur.next

	def search(self,item):
		cur = self._head
		while cur:
			if cur.elem == item:
				return true
			else:
				cur = cur.next
		return False	

4. 链表和顺序表的比较。
   
   链表和顺序表是完全不同的操作，链表耗时主要是在遍历查找，删除和插入操作本身都是O(1)的，顺序表查找很快，主要耗时的操作是拷贝覆盖。
5. 双向链表。

class node:
	def __init__(self,item):
		self.val = item
		self.next = None
		self.prev = None
class DoubleLinklist:
	def __init__(self,node = None):
		self._head = node
	def is_empty(self):
		return not self._head
	def length(self):
		cnt,cur = 0,self._head
		while cur：
			cnt += 1
			cur = cur.next
		return cnt 
	def add(self,item):
		node = Node(item)
		node.next = self._head
		self._head,node.next.prev = node,node
	def append(self,item):
		if not self._head:
			return Node(item)
		cur = self._head
		while cur.next:
			cur = cur.next
		node = Node(item)
		cur.next,node.prev = node,cur
	def insert(self,pos,item):
		if pos<=0:
			self.add(item)
		elif pos>(self.length()-1):
			self.append(item)
		else:
			cur = self._head
			cnt = 0
			while cnt<pos:
				cnt += 1
				cur = cur.next
			node = Node(item)
			node.next,node.prev = cur,cur.prev 
			cur.prev.next,cur.prev = node,node
	def remove(self,item):
		cur = self._head
		while cur:
			if cur.val == 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

6. 单向循环链表(环)。

class RecurSingleLL:
	def __init__(self,node):
		self._head = node
		if node:
			node.next = node
	
	def add(self,item):
		node = Node(item)
		if not self._head:
			self._head =node
			node.next = node
			return 
		cur = self._head
		while cur.next:
			cur = cur.next
		node.next,self._head = self._head,node
		cur.next = self._head

	def append(self,item):
		node =Node(item)
		if not self._head:
			self._head =node
			node.next = node
			return 
		cur = self._head
		while cur.next != self._head:
			cur = cur.next
		cur.next,node.next = node,self._head

	def length(self):
		cur = self._head
		if not cur:
			return 0
		cnt = 1
		while cur.next != self._head:
			cnt += 1
			cur = cur.next
		return cnt
	
	def insert(self,pos,item):
		if pos<=0:
			self.add(item)
		elif pos>(self.length()-1):
			self.append(item)
		else:
			cur = self._head
			cnt = 0
			while cnt<pos:
				cnt += 1
				cur = cur.next
			node = Node(item)
			node.next,node.prev = cur,cur.prev 
			cur.prev.next,cur.prev = node,node
	
	def search(self,item):
		if not self._head: return False
		cur = self._head
		while cur.next!=self._head:
			if cur.val == item:
				retrun True
			cur = cur.next
		if cur.val == item:
			return True
		return False
	
	def remove(self,item):
		if not self._head: return
		cur = self._head
		pre = None
		while cur.next != self._head:
			if cur.val == item:
				if cur == self._head:
					rear = self._head
					while rear.next != self._head:
						rear = rear.next
					rear.next = self._head 
					self._head = cur.next
					return 
				else:
					pre.next = cur.next
					return
			else:
				pre,cur = cur,cur.next
		if cur.val == item:
			if cur == self._head:
				self._head = None
			else:
				pre.next = cur.next

7. 总结上述方法中insert, remove方法最麻烦。
8. 双向循环链表？
9. 栈，描述的是操作，线性表描述的是数据如何存放。(LIFO)，压栈也叫入栈。

class stack：
	def __init__(self):
		self._items = []
	
	def push(self,item):
		self.items.append(item)
		
	def pop(self,ind):
		self.items.pop()
	
	def peek(self):
		if not self._items: return None
		return self._items[-1]
	
	def size(self):
		return len(self._items)

10. 队列与双端队列的实现。

class dequeue:
	def __init__(self):
		self._items = []
	def add(self,item):
		self._items.insert(0,item)
	def append(self,item):
		self._items.append(item)
	def pop_front(self):
		if not self._items: return None
		return self._items.pop(0)
	def pop_rear(self):
		if not self._items: return None
		return self._items.pop()
	def size(self):
		return len(self._items)