「数据结构」二叉树的遍历以及Python实现
Sina Weibo：小锋子Shawn
Tencent E-mail：[email protected]
http://blog.csdn.net/dgyuanshaofeng/article/details/78015084
1、遍历的种类和理解[1]
先序遍历（preorder traversal）：先处理当前的节点，再处理左、右子树。用法例子：利用节点深度标志每一个节点。实现：递归。
中序遍历（inorder ~）：首先遍历左子树，然后是当前的节点，最后遍历右子树。用法例子：打印已经排好序的一排树。这个好理解，左子树的节点的值总是小于当前的节点的值，而当前的节点的值总是小于右子树任一节点的值。运行时间：O（N）。因为有N个节点，然后要判断节点是否为空节点。实现：递归。
后序遍历（postorder ~）：先处理左、右子树，再处理当前的节点。用法例子：计算一个节点的高度。运行时间：O（N）。实现：递归。
层次遍历（level-order ~）：所有深度为D的节点要在深度D+1的节点之前进行处理，也就是逐层处理，每层处理节点的时候从左到右。实现：利用队列。
2、Python实现[2][3]
主要参考了资料[2]的代码，然后我使用的是Python3，发现输出有一些奇怪，改了一些代码，接着发现递归过程会使用多重嵌套，然后找到了一个解嵌套，将树展开的一行。代码如下：
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 01:49:41 2017
@author: Shawn Yuen
"""
# a helper function
def flatten(ll):
if isinstance(ll, list):
for i in ll:
for element in flatten(i):
yield element
else:
yield ll
# Node Class: left and right, also middel
class Node(object):
def __init__(self, elem=-1, lchild=None, rchild=None):
self.elem = elem
self.lchild = lchild
self.rchild = rchild
# Binary Tree Class
class Tree(object):
def __init__(self):
self.root = Node()
self.myQueue = []
# Add a Node for a Tree
def add(self, elem):
node = Node(elem)
if self.root.elem == -1:
self.root = node
self.myQueue.append(self.root)
else:
treeNode = self.myQueue[0]
if treeNode.lchild == None:
treeNode.lchild = node
self.myQueue.append(treeNode.lchild)
else:
treeNode.rchild = node
self.myQueue.append(treeNode.rchild)
self.myQueue.pop(0)
def preorder_recursion(self, root):
ArrayList = list()
#preoder traversal using recursion
if root == None:
return
#print(root.elem)
ArrayList.append(root.elem)
if root.lchild != None:
ArrayList.append(self.preorder_recursion(root.lchild))
if root.rchild != None:
ArrayList.append(self.preorder_recursion(root.rchild))
return ArrayList
def inorder_recursion(self, root):
ArrayList = list()
#inorder traversal
if root == None:
return
if root.lchild != None:
ArrayList.append(self.inorder_recursion(root.lchild))
#print(root.elem)
if root.elem != None:
ArrayList.append(root.elem)
if root.rchild != None:
ArrayList.append(self.inorder_recursion(root.rchild))
return ArrayList
def postorder_recursion(self, root):
ArrayList = list()
#postorder traversal
if root == None:
return
if root.lchild != None:
ArrayList.append(self.postorder_recursion(root.lchild))
if root.rchild != None:
ArrayList.append(self.postorder_recursion(root.rchild))
if root.elem != None:
#print(root.elem)
ArrayList.append(root.elem)
return ArrayList
def preorder_stack(self, root):
ArrayList = list()
if root == None:
return
myStack = []
node = root
while node or myStack:
while node:
#print(node.elem)
ArrayList.append(node.elem)
myStack.append(node)
node = node.lchild
node = myStack.pop()
node = node.rchild
return ArrayList
def inorder_stack(self, root):
ArrayList = list()
if root == None:
return
myStack = []
node = root
while node or myStack:
while node:
myStack.append(node)
node = node.lchild
node = myStack.pop()
#print(node.elem)
ArrayList.append(node.elem)
node = node.rchild
return ArrayList
def postorder_stack(self, root):
ArrayList = list()
if root == None:
return
myStack1 = []
myStack2 = []
node = root
myStack1.append(node)
while myStack1:
node = myStack1.pop()
if node.lchild:
myStack1.append(node.lchild)
if node.rchild:
myStack1.append(node.rchild)
myStack2.append(node)
while myStack2:
#print(myStack2.pop().elem)
ArrayList.append(myStack2.pop().elem)
return ArrayList
def levelorder_queue(self, root):
ArrayList = list()
if root == None:
return
myQueue = []
node = root
myQueue.append(node)
while myQueue:
node = myQueue.pop(0)
#print(node.elem)
ArrayList.append(node.elem)
if node.lchild != None:
myQueue.append(node.lchild)
if node.rchild != None:
myQueue.append(node.rchild)
return ArrayList
if __name__ == "__main__":
# please modify this parameter
###
N = 15 # the number of Node in a Tree
###
elems = range(N)
tree = Tree() # new/create a Tree
for elem in elems:
tree.add(elem) # add Node into Tree
print("Level-order Traversal using Queue:")
print(tree.levelorder_queue(tree.root))
print("\nPreorder Traversal using Recursion:")
flattenlist = flatten(tree.preorder_recursion(tree.root))
print(list(flattenlist))
print("\nInorder Traversal using Recursion:")
flattenlist = flatten(tree.inorder_recursion(tree.root))
print(list(flattenlist))
print("\nPostorder Traversal using Recursion:")
flattenlist = flatten(tree.postorder_recursion(tree.root))
print(list(flattenlist))
print("\nPreorder Traversal using Stack:")
print(tree.preorder_stack(tree.root))
print("\nInorder Traversal using Stack:")
print(tree.inorder_stack(tree.root))
print("\nPostorder Traversal using Stack:")
print(tree.postorder_stack(tree.root))Level-order Traversal using Queue:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
Preorder Traversal using Recursion:
[0, 1, 3, 7, 8, 4, 9, 10, 2, 5, 11, 12, 6, 13, 14]
Inorder Traversal using Recursion:
[7, 3, 8, 1, 9, 4, 10, 0, 11, 5, 12, 2, 13, 6, 14]
Postorder Traversal using Recursion:
[7, 8, 3, 9, 10, 4, 1, 11, 12, 5, 13, 14, 6, 2, 0]
Preorder Traversal using Stack:
[0, 1, 3, 7, 8, 4, 9, 10, 2, 5, 11, 12, 6, 13, 14]
Inorder Traversal using Stack:
[7, 3, 8, 1, 9, 4, 10, 0, 11, 5, 12, 2, 13, 6, 14]
Postorder Traversal using Stack:
[7, 8, 3, 9, 10, 4, 1, 11, 12, 5, 13, 14, 6, 2, 0]
参考资料：
[1] 数据结构与算法分析：C语言描述
[2] python实现二叉树的遍历
[3] 多层嵌套（树状结构）展开