通用算法 - [树结构] -二叉树的一些基本操作（一）
1、前言
数组、链表、二叉树、动态规划、栈与队列是面试中常考的知识点，而在这几个知识点中，二叉树属于难度比较大的部分，因此在这里总结一下二叉树常考的操作，包括：
（1）二叉树的递归遍历；
（2）二叉树的非递归遍历；
（3）求二叉树叶子节点的个数；
（4）求二叉树的深度；
（5）在二叉树中查找某颗子树；
（6）求二叉树中和为某个值的路径；
（7）求二叉树中的最大路径和；
（8）二叉树的镜像；
（9）判断某个序列是否是二叉搜索树的后序遍历序列；
（10）二叉搜索树和双向链表的相互转换；
（11）树中两个结点的最近祖先；
（12）二叉树搜索树的插入与删除；
（13）堆的插入与删除；
（14）判断一棵树是不是平衡二叉树；
（15）平衡二叉树的调整；
2、二叉树的基本操作
（1）二叉树的递归遍历
递归的形式非常简洁，几行代码即可搞定。前序、后序、中序遍历的形式基本一样，只是输出结点值的时机不一样。
基本思想：如果该结点为叶结点，则直接返回，否则，看该结点的左孩子是否为空，如果不为空，则递归的遍历其左孩子；接着看其右孩子是否为空，如果不为空，则递归的遍历其右孩子；
代码实现：
def PreOrder_recursion(rootnode):
if rootnode == None:
return
print(rootnode.val)
if rootnode.left != None:
PreOrder_recursion(rootnode.left)
if rootnode.right != None:
PreOrder_recursion(rootnode.right)
return
def MidOrder_recursion(rootnode):
if rootnode == None:
return
if rootnode.left != None:
MidOrder_recursion(rootnode.left)
print(rootnode.val)
if rootnode.right != None:
MidOrder_recursion(rootnode.right)
return
def BackOrder_recursion(rootnode):
if rootnode == None:
return
if rootnode.left != None:
BackOrder_recursion(rootnode.left)
if rootnode.right != None:
BackOrder_recursion(rootnode.right)
print(rootnode.val)
return
（2）二叉树的非递归遍历
基本思想：如果采用非递归遍历，我们需要使用一个栈来模拟函数的递归调用。对于三种遍历方式，我们都采用push当前结点->push左子树->pop左子树->push右子树->pop右子树的方式，只是不同的遍历方式，输出结点值的时机不同。
对于前序遍历来说，每次访问到一个节点，即每次要将节点进栈时，输出该节点的值；【即在左右节点入栈时输出左右子节点的值】
对于中序遍历来说，每次将当前节点的右节点进栈时，输出当前节点的值；【即在右节点进栈、以及pop叶节点的时候，输出当前节点的值】
对于后序遍历来说，每次将节点从栈中弹出的时候，输出当前节点的值。【即在pop的时候输出当前节点的值】
另外，我们还需要一个last_pop指针来记录上次pop的节点；
如果当前节点的左节点非空，并且左节点和子节点都不是上次last_pop，则将左节点进栈；
如果当前节点的右节点非空，也不是last_pop，且当前节点的左节点为空或者左节点是last_pop，则将右节点进栈；
否则的话，让当前节点出栈，让当前节点标记为last_pop。
- 注意，这里有两个比较重要的数据结构：
- 当前节点：栈顶元素；
- last_pop：上一次pop出去的结点；
当前结点被pop有两种情况，一是当前结点为叶节点（左节点 和右节点都为空），二是当前结点的左右结点都已经被访问过了（右节点为last_pop）
二叉树的前序、中序、后序遍历采用的都是深度优先策略。
代码实现：
def PreOrder_Norecursion(rootnode):
stack = []
stack.append(rootnode)
print(rootnode.val,end="")
last_pop = rootnode
while len(stack) != 0:
curnode = stack[-1]
if curnode.left != None and curnode.left != last_pop and curnode.right != last_pop:
stack.append(curnode.left)
print(curnode.left.val,end="")
elif curnode.right != None and curnode.right != last_pop and (curnode.left == None or curnode.left == last_pop):
stack.append(curnode.right)
print(curnode.right.val,end="")
else:
stack.pop()
last_pop = curnode
return
def MidOrder_Norecursion(rootnode):
stack = []
stack.append(rootnode)
last_pop = rootnode
while len(stack) != 0:
curnode = stack[-1]
if curnode.left != None and curnode.left != last_pop and curnode.right != last_pop:
stack.append(curnode.left)
elif curnode.right != None and curnode.right != last_pop and (curnode.left == None or curnode.left == last_pop):
stack.append(curnode.right)
print(curnode.val,end="")
else:
stack.pop()
last_pop = curnode
if curnode.right == None:
print(curnode.val,end="")
return
def BackOrder_Norecursion(rootnode):
stack = []
stack.append(rootnode)
last_pop = rootnode
while len(stack) != 0:
curnode = stack[-1]
if curnode.left != None and curnode.left != last_pop and curnode.right != last_pop:
stack.append(curnode.left)
elif curnode.right != None and curnode.right != last_pop and (curnode.left == None or curnode.left == last_pop):
stack.append(curnode.right)
else:
stack.pop()
last_pop = curnode
print(curnode.val,end="")
return
（3）二叉树种叶子节点的个数
基本思路：使用变量leaf_count对叶节点进行计数，在遍历二叉树时，如果遇到叶节点，则leaf_count 的值加1。
代码实现：
def LeafNums_Norecursion(rootnode):
leaf_count = 0
stack = []
stack.append(rootnode)
last_pop = rootnode
while len(stack) != 0:
curnode = stack[-1]
if curnode.left != None and curnode.left != last_pop and curnode.right != last_pop:
stack.append(curnode.left)
elif curnode.right != None and curnode.right != last_pop and (curnode.left == None or curnode.left == last_pop):
stack.append(curnode.right)
else:
stack.pop()
last_pop = curnode
if curnode.left == None and curnode.right == None:
leaf_count += 1
return leaf_count
leaf_count2 = 0
def LeafNums_Recursion(rootnode):
if rootnode == None:
return
if rootnode.left == None and rootnode.right == None:
global leaf_count2
leaf_count2 += 1
if rootnode.left != None:
LeafNums_Recursion(rootnode.left)
if rootnode.right != None:
LeafNums_Recursion(rootnode.right)
return
（4）二叉树的深度
基本思想：
（1）递归：如果节点为空，则深度为0，否则，该树的深度等于左子树的深度与右子树深度的最大值+1
（2）非递归：stack模拟函数的递归调用，那么栈中元素的最大数量即为树的深度。
代码实现：
def Maxdepth_Recursion1(rootnode):
# 遇到空节点才返回
if rootnode == None:
return 0
left_depth = Maxdepth_Recursion1(rootnode.left)
right_depth = Maxdepth_Recursion1(rootnode.right)
root_depth = max(left_depth, right_depth) + 1
return root_depth
def Maxdepth_Recursion2(rootnode):
# 遇到叶节点或者空节点，返回，避免多递归一层。
if rootnode == None:
return 0
if rootnode.left == None and rootnode.right == None:
return 1
left_depth = 0
if rootnode.left != None:
left_depth = Maxdepth_Recursion2(rootnode.left)
right_node = 0
if rootnode.right != None:
right_depth = Maxdepth_Recursion2(rootnode.right)
root_depth = 0
root_depth = max(left_depth, right_depth) + 1
return root_depth
def Maxdepth_NoRecursion(rootnode):
stack = []
stack.append(rootnode)
last_pop = rootnode
depth = 0
while len(stack) != 0:
curnode = stack[-1]
depth = max(len(stack), depth)
if curnode.left != None and curnode.left != last_pop and curnode.right != last_pop:
stack.append(curnode.left)
elif curnode.right != None and curnode.right != last_pop and (curnode.left == None or curnode.left == last_pop):
stack.append(curnode.right)
else:
stack.pop()
last_pop = curnode
return depth
>>下一篇：通用算法 - [树结构] -二叉树的一些基本操作（二）