1，利用类来构建结点，利用函数递归来构建树
2，因为左子树的结点编号是父节点的2倍，右子树的结点编号是父节点的2倍+1，所以可以用数组模拟建树的过程
构建二叉树
第一种构建方式
class treenode():#二叉树节点
def __init__(self,val,lchild=None,rchild=None):
self.val=val #二叉树的节点值
self.lchild=lchild #左孩子
self.rchild=rchild #右孩子
def creat_tree(root,vals):
if len(vals)==0:#终止条件：val用完了
return root
if vals[0]!='#':#本层需要干的就是构建root、root.lchild、root.rchild三个节点。
root = treenode(vals[0])
vals.pop(0)
root.lchild = creat_tree(root.lchild,val)
root.rchild = creat_tree(root.rchild,val)
return root#本次递归要返回给上一次的本层构造好的树的根节点
else:
root=None
vals.pop(0)
return root#本次递归要返回给上一次的本层构造好的树的根节点
if __name__ == '__main__':
root = None
strs="abc##d##e##"#前序遍历扩展的二叉树序列
vals = list(strs)
roots=creat_tree(root,vals)#roots就是我们要的二叉树的根节点。第二种构建方式
#存储结构的创建
class node:
def __init__(self,data):
self.data=data#数据域
self.left=None#指向左子树根节点的指针
self.right=None#指向右子树根节点的指针
root=None#如果根节点不存在
l=[1,2,None,3,5,2,1]#假设题目给出列表形式的二叉树各节点数据
def newNode(input_list=[]):#创建二叉树，即二叉树插入
if input_list is None or len(input_list)==0:#如果列表为空
return None
data=input_list.pop(0)#取出并删除“当前”列表第一个数据
if data is None:#到达空树，递归边界
return None
root=node(data)#将该数据设置为根节点的数据，并创建此根节点的存储地址。
root.left=newNode(input_list)#该根节点的左节点为“当前”列表的第二个数据
root.right=newNode(input_list)#该根节点的右节点为“当前”列表的第三个数据
#左右节点的递归顺序要根据题目给出的前中后层序排序改变。当前为前序遍历插入
#中序遍历插入
# root.left=newNode(input_list)
# root = node(data)
# root.right=newNode(input_list)
#后序遍历插入
# root.left=newNode(input_list)
# root.right=newNode(input_list)
# root=node(data)
#层序遍历插入
return root
newNode(l)二叉树的四种遍历
#二叉树遍历
#前序遍历
#root是构建二叉树后得到的根结点
def preorder(root):
if root==None:
return#到达空树，递归边界
print(root.data)#访问根节点
preorder(root.left)#访问左子树
preorder(root.right)#访问右子树
#中序遍历
def inorder(root):
if root==None:
return#到达空树，递归边界
inorder(root.left) # 访问左子树
print(root.data)#访问根节点
inorder(root.right)#访问右子树
#后序遍历
def postorder(root):
if root==None:
return#到达空树，递归边界
postorder(root.left)#访问左子树
postorder(root.right)#访问右子树
print(root.data) # 访问根节点
#层序遍历
from queue import Queue
def layerorder(root):
q=Queue()#注意队列里是存地址
q.put(root)#将根节点地址入队
while not q.empty():
newroot=q.get()#取出队首元素
q.pop()
print(newroot.data)#访问队首元素
if newroot.left is not None:#左子树非空
q.put(newroot.left)
if newroot.right is not None:#右子树非空
q.put(newroot.right)
#二叉树结点的查找,修改
goaldata=10#目标数据
newdata=11#新的数据
def search(root,goaldata,newdata):#先传进根节点
if root==None:
return
if root.data==goaldata:
root.data=newdata
# 再依次传进左右子节点
search(root.left,goaldata,newdata)#往左子树搜索x
search(root.right,goaldata,newdata)#往右子树搜素x二叉树题目其一：已知两种遍历求其他所有遍历
结论:中序序列可以与先序序列、后序序列、层序序列中的任意一个来构建唯一的二叉树，而后三者两两搭配或是三个一起上都无法构建唯一的二叉树。原因是先序、后序、层序均是提供根结点,作用是相同的,都必须由中序序列来区分出左右子树。
L2-006 树的遍历
已知中后求层序
class node:
def __init__(self,data):
self.data=data
self.left=None
self.right=None
n=int(input())
l1=list(map(int,input().split()))
l2=list(map(int,input().split()))
def buildTree(inorder,postorder):
def helper(in_left,in_right):
if in_left>in_right:
return None
data=postorder.pop()#后序排序从后依次弹出，遵循根右左，故一开始是根，之后一直右，然后左，如何判断该节点是左右，只需看in_left>in_right即可，一旦in_left<=in_right，说明右已经没有，开始进行左。
root=node(data)
index=idx_map[data]
root.right = helper(index + 1, in_right)#为什么root.right必须放在root.left上面，在data是按后序排序逆序弹出
#弹出根节点后就弹出右节点，这个时候如果先遍历左子树会找不到左子树的根节点
root.left=helper(in_left,index-1)
return root
idx_map={val:idx for idx,val in enumerate(inorder)}#将中序列表的值和下标对应
return helper(0,len(inorder)-1)
p=buildTree(l2,l1)#得到的是一堆root数据结构的首地址，也就是二叉树根节点的地址
# print(p)
q=[p]#将首地址放到列表结构中
# print(q.pop(0))
res=[]
while(len(q)!=0):
m=q.pop(0)#取出首地址
if m!=None:
res.append(m.data)
if m.left!=None:
q.append(m.left)
if m.right!=None:
q.append(m.right)
print(*res)L2-011 玩转二叉树
已知前中镜像翻转后求层
前序遍历倒过来就是后序遍历的镜像
from queue import Queue
n=int(input())
zx=list(map(int,input().split()))
qx=list(map(int,input().split()))
class node():
def __init__(self,data):
self.data=data
self.left=None
self.right=None
idx_map={val:i for i,val in enumerate(zx)}
def coms(inl,inr):
if inl>inr:
return None
data=qx.pop(0)#在前序中找到根节点
#前序排序从前依次弹出，遵循根左右，故一开始是根，之后一直左，然后左，如何判断该节点是左右，只需看in_left>in_right即可，一旦in_left<=in_right，说明左已经没有，开始进行右。
index=idx_map[data]#利用根节点的值找到其下标
root=node(data)#建立二叉树
#再利用下标将其分开
#l.append(data)前序遍历
root.left = coms(inl, index - 1)
#l.append(data)中序遍历
root.right = coms(index + 1, inr)
# l.append(data)后序遍历
return root
p=coms(0,len(zx)-1)#得到的是一堆root数据结构的首地址，也就是二叉树根节点的地址
# print(p)
q=[p]#将首地址放到列表结构中
# print(q.pop(0))
res=[]
while(len(q)!=0):
m=q.pop(0)#取出首地址
if m!=None:
res.append(m.data)
if m.right!=None:
q.append(m.right)
if m.left!=None:
q.append(m.left)
print(*res)from queue import Queue
n=int(input())
zx=list(map(int,input().split()))
qx=list(map(int,input().split()))
class node():
def __init__(self,data):
self.data=data
self.left=None
self.right=None
idx_map={val:i for i,val in enumerate(zx)}
def coms(inl,inr):
if inl>inr:
return None
data=qx.pop(0)#在前序中找到根节点
index=idx_map[data]#利用根节点的值找到其下标
root=node(data)#建立二叉树
#再利用下标将其分开
#l.append(data)前序遍历
root.left = coms(inl, index - 1)
#l.append(data)中序遍历
root.right = coms(index + 1, inr)
# l.append(data)后序遍历
return root
l=[]
def level(node):
queue=Queue()
queue.put(node)
while not queue.empty():
node=queue.get()
l.append(node.data)
if node.right is not None:#先加入右节点，做镜像翻转
queue.put(node.right)
if node.left is not None:
queue.put(node.left)
level(coms(0,len(zx)-1))
print(*l)L2-035 完全二叉树的层序遍历
由于树是递归实现的，后序排序符合递归顺序，而层序排序的顺序可以为我们提供每一次递归所满足的代数式。
n=int(input())
l=list(map(int,input().split()))
tree=[0]*n
def dfs(x):
global index
if x>n:
return
dfs(x*2)
dfs(x*2+1)
tree[x-1]=l[index]
index+=1
index=0
dfs(1)
print(*tree)二叉搜素树(BST)
二叉查找树一个实用的性质：对二叉查找树进行中序遍历，遍历的结果是有序的。
这是由于二叉查找树本身的定义中就包含了左子树<根结点<右子树的特点，而中序遍历的访问顺序也是左子树→根结点→右子树,因此,所得到的中序遍历序列是有序的。
# -*- coding:utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
class BSTNode:
"""
定义一个二叉树节点类。
以讨论算法为主，忽略了一些诸如对数据类型进行判断的问题。
"""
def __init__(self, data, left=None, right=None):
"""
初始化
:param data: 节点储存的数据
:param left: 节点左子树
:param right: 节点右子树
"""
self.data = data
self.left = left
self.right = right
class BinarySortTree:
"""
基于BSTNode类的二叉排序树。维护一个根节点的指针。
"""
def __init__(self):
self._root = None
def is_empty(self):
return self._root is None
def search(self, key):
"""
关键码检索
:param key: 关键码
:return: 查询节点或None
"""
bt = self._root
while bt:
entry = bt.data
if key < entry:
bt = bt.left
elif key > entry:
bt = bt.right
else:
return entry
return None
def insert(self, key):
"""
插入操作
:param key:关键码
:return: 布尔值
"""
if self.is_empty():
self._root = BSTNode(key)
bt = self._root
while True:
entry = bt.data
if key < entry:
if bt.left is None:
bt.left = BSTNode(key)
bt = bt.left
elif key > entry:
if bt.right is None:
bt.right = BSTNode(key)
bt = bt.right
else:
bt.data = key
return
def delete(self, key):
"""
二叉排序树最复杂的方法
:param key: 关键码
:return: 布尔值
"""
p, q = None, self._root # 维持p为q的父节点，用于后面的链接操作
if not q:
print("空树！")
return
while q and q.data != key:
p = q
if key < q.data:
q = q.left
else:
q = q.right
if not q: # 当树中没有关键码key时，结束退出。
return
# 上面已将找到了要删除的节点，用q引用。而p则是q的父节点或者None（q为根节点时）。
if not q.left:
if p is None:
self._root = q.right
elif q is p.left:
p.left = q.right
else:
p.right = q.right
return
# 查找节点q的左子树的最右节点，将q的右子树链接为该节点的右子树
# 该方法可能会增大树的深度，效率并不算高。可以设计其它的方法。
r = q.left
while r.right:
r = r.right
r.right = q.right
if p is None:
self._root = q.left
elif p.left is q:
p.left = q.left
else:
p.right = q.left
def _pre_order(self, node=None):
if node is None:
node = self._root
yield node.data
if node.left is not None:
for item in self._pre_order(node.left):
yield item
if node.right is not None:
for item in self._pre_order(node.right):
yield item
def _mid_order(self, node=None):
if node is None:
node = self._root
if node.left is not None:
for item in self._mid_order(node.left):
yield item
yield node.data
if node.right is not None:
for item in self._mid_order(node.right):
yield item
def _mid_order1(self):
"""
实现二叉树的中序遍历算法,
展示我们创建的二叉排序树.
直接使用python内置的列表作为一个栈。
:return: data
"""
stack = []
node = self._root
while node or stack:
while node:
stack.append(node)
node = node.left
node = stack.pop()
yield node.data
node = node.right
def _post_order(self, node=None):
if node is None:
node = self._root
if node.left is not None:
for item in self._post_order(node.left):
yield item
if node.right is not None:
for item in self._post_order(node.right):
yield item
yield node.data
def pre_order(self):
return list(self._pre_order())
def mid_order(self):
return list(self._mid_order()) # return list(self._mid_order1())
def post_order(self):
return list(self._post_order())
if __name__ == '__main__':
lis = [62, 58, 88, 47, 73, 99, 35, 51, 93, 37]
bs_tree = BinarySortTree()
for i in range(len(lis)):
bs_tree.insert(lis[i])
print "先序遍历：", bs_tree.pre_order()
print "中序遍历：", bs_tree.mid_order()
print "后序遍历：", bs_tree.post_order()L3-010 是否完全二叉搜索树
因为左子树的结点编号是父节点的2倍，右子树的结点编号是父节点的2倍+1，所以可以用数组模拟建树的过程;
最后题目要求层序输出比较简单，直接按编号大小输出即可;
还有一问是判断该树是否为完全二叉树，完全二叉树的定义是若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，所以最后的结点编号肯定和n是相等的。
平衡二叉树
并查集
路径压缩
哈夫曼树
