数据结构之树----Python

尊重知识产权

• 常见数据结构（二） - 树（二叉树，红黑树，B树）
• 漫画：什么是红黑树？
• 二叉树的Python实现
• python实现二叉树
• python创建以及遍历二叉树
• 二叉树基础知识+Python实现 这个博客很好的

相对于二叉树，红黑树、B树是比较困难的。所以对于红黑树、B树，这里可能只是简单的介绍，不做深入（主要是我还理解的不是那么，嗯，你懂的）。

树

什么是树？ 树（Tree）是n(n≥0)n(n≥0)个结点的有限集。

二叉树

二叉树（Binary Tree）是一种特殊的树型结构，它的特点是每个结点至多有两棵子树（即二叉树中不存在度大于2的结点），且二叉树的子树有左右之分，其次序不能任意颠倒（有序树）。

基本形式----代码：

#是不是像一个链表中的节点？嘿嘿，可以这样理解的
class Node(object):
	def __init__(self, dataval):
		self.dataval = dataval
		self.rightval = None
		self.leftval = None

一般的方法创建树

class Node:
	def __init__(self,dataval):
		self.dataval = dataval
		self.leftchild = None
		self.rightchild = None

class Bi_tree:
	def __init__(self):
		self.rootval = None
		self.queue = [] #将节点的值存放在列表中
	def creat(self,newdata):
		Newnode = Node(newdata)
		if self.rootval == None:
			self.rootval = Newnode
			self.queue.append(self.rootval)
		else:
			laste = self.queue[0]
			# print(laste.dataval)
			if laste.leftchild == None:
				laste.leftchild = Newnode
				self.queue.append(laste.leftchild)
			else:
				laste.rightchild = Newnode
				self.queue.append(laste.rightchild)
				#如果该结点存在右子树，将此结点丢弃。
				self.queue.pop(0)

		#先序遍历
	def pre_order(self,rootval):
		#主要是利用递归算法
		#第一步：临界点---有回
		if rootval == None:
			return None
		#第二步：算法（根节点->左子树->右子树）---可去
		print(rootval.dataval,end=' ')
		self.pre_order(rootval.leftchild)
		self.pre_order(rootval.rightchild)
	def mid_order(self,rootval):
		#主要利用递归算法
		#第一步：临界点---有回
		if rootval == None:
			return None
		#第二步：算法（左子树->根节点->右子树）
		self.pre_order(rootval.leftchild)
		print(rootval.dataval,end=' ')
		self.pre_order(rootval.rightchild)
	def post_order(self,rootval):
		if rootval == None:
			return None
		self.pre_order(rootval.leftchild)
		self.pre_order(rootval.rightchild)
		print(rootval.dataval,end=' ')
	#层次遍历----广度优先遍历
	def level_order(self,rootval):
		if rootval is None:
			return None
		q = []
		# 首先将根节点入队
		q.append(rootval)
		# 列表为空时，循环终止
		while len(q) != 0:
			length = len(q)
			for i in range(length):
				# 将同层节点依次出队
				r = q.pop(0)
				if r.leftchild is not None:
				# 非空左孩子入队
					q.append(r.leftchild)
				if r.rightchild is not None:
					# 非空右孩子入队
					q.append(r.rightchild)
				print(r.dataval)

if __name__ == '__main__':
	li = Bi_tree()
	li.creat('1')
	li.creat('2')
	li.creat('3')
	li.creat('4')
	li.creat('5')
	# li.pre_order(li.rootval)
	# li.mid_order(li.rootval)
	# li.post_order(li.rootval)
	li.level_order(li.rootval)

二叉树遍历转换

由中序和另外任一种遍历可以唯一确定一颗二叉树，而仅有前序遍历和后序遍历无法确定一颗唯一的二叉树。

尊重知识产权：

二叉树前序中序转后序、层次。

上图：

因此首先找到根节点在中序遍历中的位置。可以看出来以根节点作为分界线右边为右子树，因此直接递归即可，而左边则由于右根节点需要分解。

先序遍历中，递归从根节点后一个结点开始，而结束结点为开始节点加上左子树结点的个数，而左子树结点的个数可以由中序遍历根节点左边的个数确定。

最后可以得到如下图：

遍历转化的代码----例子

题目：已知二叉树前序、中序遍历用python求后序遍历

算法：

• 先找到根节点
• 递归算法

def last_sort(str1, str2):
    if len(str2) <= 1:
        return str2
    else:
        return last_sort(str1[1:str2.index(str1[0])+1], str2[:str2.index(str1[0])]) + last_sort(str1[str2.index(str1[0])+1:],
                                                                                                str2[str2.index(str1[0])+1:
                                                                                                ]) + str1[0:1]

str1 = ['A', 'B', 'D', 'C', 'E', 'F']
str2 = ['D', 'B', 'A', 'E', 'C', 'F']
print(last_sort(str1, str2))

题目：已知二叉树后序、中序遍历用python求先序遍历

def last_sort(str1, str2):
    if len(str2) <= 1:
        return str2
    else:
        return [str1[-1]] + last_sort(str1[0 :str2.index(str1[-1])], str2[0:str2.index(str1[-1])]) + last_sort(str1[str2.index(str1[-1]):-1],
                                                                                                str2[str2.index(str1[-1])+1: ]) 

# str1 = ['A', 'B', 'D', 'C', 'E', 'F']
str2 = ['D', 'B', 'A', 'E', 'C', 'F']
str1 = ['D', 'B', 'E', 'F', 'C', 'A']
print(last_sort(str1, str2))

接下来的一节将会是剑指offer上的二叉树部分。敬请关注