03 栈、队列、双端队列、二叉树code

1.栈

# coding:utf-8

class Stack(object):
	"""栈"""
	def __init__(self):
		self.__list = []

	def push(self,item):
		# 添加元素至栈顶
		self.__list.append(item)

	def pop(self):
		# 弹出栈顶元素
		return self.__list.pop()

	def peek(self):
		# 返回栈顶元素
		if self.__list:
			return self.__list[-1]
		else:
			return None

	def is_empty(self):
		# 判断是否为空
		return self.__list == []

	def size(self):
		return len(self.__list)

if __name__ == '__main__':
	s = Stack()
	s.push(1)
	s.push(2)
	s.push(3)
	s.push(4)
	print(s.pop())
	print(s.pop())
	print(s.peek())
	print(s.is_empty())
	print(s.size())

2.队列

# coding:utf-8
class Queue(object):
	"""队列"""
	def __init__(self):
		self.__list = []

	def enqueue(self,item):
		# 添加一个元素
		self.__list.append(item)

	def dequeue(self):
		# 从队列头部删除一个元素
		return self.__list.pop(0)

	def is_empty(self):
		return self.__list == []

	def size(self):
		return len(self.__list)


if __name__ == '__main__':
	s = Queue()
	s.enqueue(1)
	s.enqueue(2)
	s.enqueue(3)
	s.enqueue(4)
	s.enqueue(5)
	print(s.dequeue())
	print(s.dequeue())
	print(s.is_empty())
	print(s.size())

3.双端队列

# coding:utf-8

class Deeue(object):
	"""双端队列"""
	def __init__(self):
		self.__list = []

	def add_front(self,item):
		# 在队列头部添加一个元素
		self.__list.insert(0,item)

	def add_rear(self,item):
		# 在队列尾部添加一个元素
		self.__list.append(item)

	def pop_front(self):
		# 从队列头部删除一个元素
		return self.__list.pop(0)

	def pop_rear(self):
		# 从队列尾部删除一个元素
		return self.__list.pop()

	def is_empty(self):
		return self.__list == []

	def size(self):
		return len(self.__list)


if __name__ == '__main__':
	s = Deeue()
	s.add_rear(1)
	s.add_rear(2)
	s.add_rear(3)
	s.add_rear(4)
	s.add_rear(5)
	print(s.pop_rear())
	print(s.pop_rear())
	print(s.is_empty())
	print(s.size())

	s.add_front(6)
	s.add_front(7)
	print(s.pop_rear())
	print(s.pop_front())

4.二叉树

# coding:utf-8

class Node(object):
	def __init__(self,item):
		self.elem = item
		self.lchild = None
		self.rchild = None

class Tree(object):
	'''二叉树'''
	def __init__(self):
		self.root = None

# 广度优先添加
	def add(self,item):
		node = Node(item)
		if self.root is None:
			self.root = node
			return
		queue = [self.root]
		while queue:
			cur_node = queue.pop(0)
			if cur_node.lchild is None:
				cur_node.lchild = node
				return
			else:
				queue.append(cur_node.lchild)
			if cur_node.rchild is None:
				cur_node.rchild = node
				return
			else:
				queue.append(cur_node.rchild)


	def breath_travel(self):
		'''广度遍历'''
		if self.root is None:
			return

		queue = [self.root]
		while queue:
			cur_node = queue.pop(0)
			print(cur_node.elem, end=" ")
			if cur_node.lchild:
				queue.append(cur_node.lchild)
			if cur_node.rchild:
				queue.append(cur_node.rchild)




# 分层输出的LeetCode题
	# def levelOrder(self, root):
	# 	if not root:
	# 		return []
	# 	res,cur_level = [],[root]
	# 	while cur_level:
	# 		temp = []
	# 		next_level = []
	# 		for i in cur_level:
	# 			temp.append(i.elem)
	# 			if i.lchild:
	# 				next_level.append(i.lchild)
	# 			if i.rchild:
	# 				next_level.append(i.rchild)
	# 			res.append(temp)
	# 			cur_level = next_level
	# 		return res
	# 	print(res)



	def preorder(self,node):
		'''先序遍历--使用递归方法，相当于每次遍历一个小子树。根的不同'''

		# 递归退出规则，到达叶子结点
		if node is None:
			return

		print(node.elem, end=" ")  # 打印根结点
		self.preorder(node.lchild)   #遍历左子树
		self.preorder(node.rchild)   #遍历右子树





	def inorder(self,node):
		'''中序遍历--使用递归方法，相当于每次遍历一个小子树。根的不同'''

		# 递归退出规则，到达叶子结点
		if node is None:
			return

		self.inorder(node.lchild)   #遍历左子树
		print(node.elem,end=" ")  # 打印根结点
		self.inorder(node.rchild)   #遍历右子树





	def postorder(self,node):
		'''后序遍历--使用递归方法，相当于每次遍历一个小子树。根的不同'''

		# 递归退出规则，到达叶子结点 
		if node is None:
			return

		self.postorder(node.lchild)   #遍历左子树
		self.postorder(node.rchild)   #遍历右子树
		print(node.elem,end=" ")  # 打印根结点

if __name__ == '__main__':
	tree = Tree()
	tree.add(0)
	tree.add(1)
	tree.add(2)
	tree.add(3)
	tree.add(4)
	tree.add(5)
	tree.add(6)
	tree.add(7)
	tree.add(8)
	tree.add(9)
	tree.breath_travel()
	print(" ")
	#tree.preorder(tree.root)
	print(" ")
	#tree.inorder(tree.root)
	print(" ")
	#tree.postorder(tree.root)
	print(" ")
	# tree.levelOrder(tree.root)