[剑指offer]python从上到下打印二叉树【面试题9.15】

在python中:

1、二叉树的表示可以用列表，如图这样的一颗二叉树:

可以表示为：

tree=['A',['B',['D',[],[]],['C',['F',[],[]],[]]],[]]

简单理解就是：如果A有两个子节点B和C，表示为tree=['A','B','C']，若A没有子节点，就是tree=['A',[],[]]

2、二叉树的实现：

（1）使用类：

# 二叉树的类实现
class BTree(object):#定义类
    def __init__(self,item):#定义方法
        #__init__类似构造器(是两个下划线)
        self.data=item
        self.leftChild=None
        self.rightChild=None
    def insertLeft(self,item):
        if self.leftChild==None:
            self.leftChild=BTree(item)
        else:
            t=BTree(item)
            t.leftChild=self.leftChild
            self.leftChild=t#使用一个交换来实现
    def insertRight(self,item):
        if self.rightChild==None:
            self.rightChild=item
        else:
            t=BTree(item)
            t.rightChild=self.rightChild
            self.rightChild=t
if __name__=='__main__':
    tree=BTree('A')#类实例化
    tree.insertRight('A')
    print(tree)

3、二叉树各种遍历及打印

层序遍历与先序、中序、后序遍历不同。层序遍历用到了队列，而先、中、后序需要用到栈。

因此，先、中、后序遍历 可以 采用递归方式来实现，而层序遍历则没有递归方式。

#各种遍历：
class node(object):
    def __init__(self,data=None,left=None,right=None):
        self.data=data
        self.left=left
        self.right=right
# tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))
#深度
def depth(tree):
    if tree==None:
        return 0
    left,right=depth(tree.left),depth(tree.right)
    return max(left,right)+1#定义在类里的
#前序遍历
#根结点-左结点-右结点
def pre_order(tree):
    if tree==None:
        return
    print(tree.data)
    pre_order(tree.left)
    pre_order(tree.right)
#中序遍历
#左结点-根结点-右结点
def mid_order(tree):
    if tree==None:
        return
    mid_order(tree.left)
    print(tree.data)
    mid_order(tree.right)
#后序遍历
#左结点-右结点-根结点
def post_order(tree):
    if tree==None:
        return
    post_order(tree.left)
    post_order(tree.right)
    print(tree.data)

#层次遍历
def level_order(tree):
    if tree==None:
        return
    ls=[]
    ls.append(tree)
    while ls:
        current=q.pop(0)#根节点
        print(current.data)
        if current.left!=None:
            q.append(current.left)
        if current.right!=None:
            q.append(current.right)

#层次打印
def level_print(tree):
    if tree==None:
        return
    q=[]
    q.append(tree)
    results={}
    level=0
    current_level_num=1
    nextlevelnum=0
    d=[]
    while q:
        current=q.pop(0)
        current_level_num-=1
        d.append(current.data)
        if current.left!=None:
            q.append(current.left)
            nextlevelnum+=1
        if current.right!=None:
            q.append(current.right)
            nextlevelnum+=1
        if current_level_num==0:
            current_level_num=nextlevelnum
            nextlevelnum=0
            results[level]=d
            d=[]
            level+=1
    print(results)

if __name__=='__main__':
    tree=node('D',node('B',node('A'),node('C')),node('E',right=node('G',node('F'))))
    print('前序遍历：')
    pre_order(tree)
    print('\n')
    print('中序遍历：')
    mid_order(tree)
    print('\n')
    print('后序遍历：')
    post_order(tree)
    print('层次遍历')
    level_print(tree)

参考：

http://www.cnblogs.com/linxiyue/p/3570071.html

http://www.cnblogs.com/whb-20160329/p/6663958.html