【数据结构与算法】Python实现、堆、栈、数组、二叉树、链表、队列

1、把二叉树转换为双向链表：

import sys
sys.setrecursionlimit(3000)  # 修改最大递归深度为3000，默认为1000实际为998

class BiTNode:

	def __init__(self):

		self.data = None
		self.lchild = None
		self.rchild = None

class Test:

	def __init__(self):

		self.pHead = None  # 双向链表的头结点
		self.pEnd = None  # 尾结点

	def arrarytotree(self,arr,start,end):
		# 数组转为树

		root = None
		if end > start:
			root = BiTNode()
			mid = int((start+end+1)/2)
			root.data = arr[mid]
			root.lchild = self.arrarytotree(arr,start,mid-1)
			root.rchild = self.arrarytotree(arr,mid+1,end)
		else:
			root = None
		return root

	def inOrderBSTree(self,root):
		# 二叉树转为双向链表

		if root == None:
			return
		
		self.inOrderBSTree(root.rchild)  # 递归左子树
		root.lchild = self.pEnd  # root的左边指向pEnd
		if self.pEnd == None:  # 如果pEnd为空，root为头结点
			self.pHead = root
		else:
			self.pEnd.rchild = root  # pEnd右边指向root
		self.pEnd = root  # pEnd后移一位指向root
		self.inOrderBSTree(root.rchild)  # 递归右子树


if __name__ == '__main__':
	arr = [1,2,3,4,5,6,7]
	test = Test()
	root = test.arrarytotree(arr,0,len(arr)-1)
	test.inOrderBSTree(root)

	print('转换后双向链表的正向遍历：')
	cur = test.pHead
	while cur != None:
		print(cur.data)
		cur = cur.rchild

	print('转换后双向链表的逆向遍历：')
	cur = test.pEnd
	while cur != None:
		print(cur.data)
		cur = cur.lchild

2、单链表的实现：

class Node(object):
	'''节点'''
	def __init__(self, data):
		self.data = data
		self.next = None

class Single_link_list(object):
	'''单链表'''
	def __init__(self,node=None):
		self.__head = node

	def isempty(self):
		return self.__head == None

	def length(self):
		cur = self.__head
		count = 0
		while cur is not None:
			count += 1
			cur = cur.next
		return count

	def travel(self):
		# 遍历链表
		cur = self.__head
		while cur is not None:
			print(cur.data,end=' ')
			cur = cur.next

	def add(self,item):
		# 往头部添加元素
		node = Node(item)
		node.next = self.__head
		self.__head = node

	def append(self, item):
		# 链表尾部添加元素, 尾插法
		node = Node(item)
		if self.isempty():
			self.__head = node
		else:
			cur = self.__head
			while cur.next is not None:
				cur = cur.next
			cur.next = node

	def insert(self,idx,item):
		# 指定位置插入元素
		if idx <= 0:
			self.add(item)
		elif idx > self.length()-1:
			self.append(item)
		else:
			pre = self.__head
			count = 0
			while count < idx -1:
				count += 1
				pre = pre.next
			node = Node(item)
			node.next = pre.next
			pre.next = node

	def remove(self,item):
		# 删除节点
		pre = None
		cur = self.__head
		while cur is not None:
			if cur.data == item:
				if cur == self.__head:
					self.__head = cur.next
				else:
					pre.next = cur.next
				break
			else:
				pre = cur
				cur = cur.next

	def serach(self,item):
		# 查找节点是否存在
		cur = self.__head
		while cur is not None:
			if cur.data == item:
				return True
			else:
				cur = cur.next
		return False

if __name__ == '__main__':
	l1 = Single_link_list()
	print(l1.isempty())
	print(l1.length())
	# l1.travel()

	l1.append(1)
	l1.append(2)
	l1.append(3)
	print(l1.isempty())
	print(l1.length())

	l1.add(0)
	l1.remove(2)
	l1.insert(1,5)
	l1.append(4)
	l1.travel()

3、顶部开始逐层打印二叉树结点数据：

from collections import deque

class BiTNode:

	def __init__(self):

		self.data = None
		self.lchild = None
		self.rchild = None

def arraytotree(arr,start,end):

	root = None
	if end >= start:
		root = BiTNode()  # 初始化树结点
		mid = int((start+end+1)/2)
		root.data = arr[mid]  # 使根结点的数据为数组的中间元素
		root.lchild = arraytotree(arr,start,mid-1)  # 递归调用左右部分数组生成root左右子树
		root.rchild = arraytotree(arr,mid+1,end)

	else:
		root = None
	return root


def printTreeLayer(root):

	if root == None:
		return

	queue = deque()  # 生成一个队列，用于节点数据的入和出
	queue.append(root)  # 存入根结点数据
	while len(queue) > 0:
		p = queue.popleft()  # 从队列左侧弹出数据并打印
		print(p.data)

		if p.lchild != None:
			queue.append(p.lchild)
		if p.rchild != None:
			queue.append(p.rchild)

if __name__ == '__main__':
	arr = [1,2,3,4,5,6,7,8,9,10]
	root = arraytotree(arr,0,len(arr)-1)
	print('树的层序遍历结果为：')
	printTreeLayer(root)

4、顶部开始逐层打印二叉树结点数据（空间复杂度O(1)）：

from collections import deque

class BiTNode:

	def __init__(self):

		self.data = None
		self.lchild = None
		self.rchild = None

def arraytotree(arr,start,end):

	root = None
	if end >= start:
		root = BiTNode()  # 初始化树结点
		mid = int((start+end+1)/2)
		root.data = arr[mid]  # 使根结点的数据为数组的中间元素
		root.lchild = arraytotree(arr,start,mid-1)  # 递归调用左右部分数组生成root左右子树
		root.rchild = arraytotree(arr,mid+1,end)

	else:
		root = None
	return root

def printAtLevel(root,level):  # 空间复杂度为big of 1

	if (root == None) or (level < 0):
		return 0
	elif level == 0:
		print(root.data)
		return 1
	else:
		return printAtLevel(root.lchild,level-1) + printAtLevel(root.rchild,level-1)

if __name__ == '__main__':
	arr = [1,2,3,4,5,6,7,8,9,10]
	root = arraytotree(arr,0,len(arr)-1)
	print('空间复杂度为Big of 1 的层序遍历结果：')
	# 按树的层数决定调用该函数的次数
	printAtLevel(root,0)
	printAtLevel(root,1)
	printAtLevel(root,2)
	printAtLevel(root,3)

5、二叉树：

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

class Tree:
	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 breadth_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)

	def preoder(self, node):
		# 前序遍历
		if node is None:
			return
		print(node.elem, end=' ')
		self.preoder(node.lchild)
		self.preoder(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.breadth_travel()
	print(' ')
	tree.preoder(tree.root)
	print(' ')
	tree.inorder(tree.root)
	print(' ')
	tree.postorder(tree.root)

6、二分查找：</