python实现二叉树和它的七种遍历

原文链接：http://blog.csdn.net/bone_ace/article/details/46718683

介绍：

树是数据结构中非常重要的一种，主要的用途是用来提高查找效率，对于要重复查找的情况效果更佳，如二叉排序树、FP-树。另外可以用来提高编码效率，如哈弗曼树。 

代码：

用python实现树的构造和几种遍历算法，虽然不难，不过还是把代码作了一下整理总结。实现功能：

• 树的构造
• 递归实现先序遍历、中序遍历、后序遍历
• 堆栈实现先序遍历、中序遍历、后序遍历
• 队列实现层次遍历

#coding=utf-8class Node(object):    """节点类"""    def __init__(self, elem=-1, lchild=None, rchild=None):        self.elem = elem        self.lchild = lchild        self.rchild = rchildclass Tree(object):    """树类"""    def __init__(self):        self.root = Node()        self.myQueue = []    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 front_digui(self, root):        """利用递归实现树的先序遍历"""        if root == None:            return        print root.elem,        self.front_digui(root.lchild)        self.front_digui(root.rchild)    def middle_digui(self, root):        """利用递归实现树的中序遍历"""        if root == None:            return        self.middle_digui(root.lchild)        print root.elem,        self.middle_digui(root.rchild)    def later_digui(self, root):        """利用递归实现树的后序遍历"""        if root == None:            return        self.later_digui(root.lchild)        self.later_digui(root.rchild)        print root.elem,    def front_stack(self, root):        """利用堆栈实现树的先序遍历"""        if root == None:            return        myStack = []        node = root        while node or myStack:            while node:                     #从根节点开始，一直找它的左子树                print node.elem,                myStack.append(node)                node = node.lchild            node = myStack.pop()            #while结束表示当前节点node为空，即前一个节点没有左子树了            node = node.rchild                  #开始查看它的右子树    def middle_stack(self, root):        """利用堆栈实现树的中序遍历"""        if root == None:            return        myStack = []        node = root        while node or myStack:            while node:                     #从根节点开始，一直找它的左子树                myStack.append(node)                node = node.lchild            node = myStack.pop()            #while结束表示当前节点node为空，即前一个节点没有左子树了            print node.elem,            node = node.rchild                  #开始查看它的右子树    def later_stack(self, root):        """利用堆栈实现树的后序遍历"""        if root == None:            return        myStack1 = []        myStack2 = []        node = root        myStack1.append(node)        while myStack1:                   #这个while循环的功能是找出后序遍历的逆序，存在myStack2里面            node = myStack1.pop()            if node.lchild:                myStack1.append(node.lchild)            if node.rchild:                myStack1.append(node.rchild)            myStack2.append(node)        while myStack2:                         #将myStack2中的元素出栈，即为后序遍历次序            print myStack2.pop().elem,    def level_queue(self, root):        """利用队列实现树的层次遍历"""        if root == None:            return        myQueue = []        node = root        myQueue.append(node)        while myQueue:            node = myQueue.pop(0)            print node.elem,            if node.lchild != None:                myQueue.append(node.lchild)            if node.rchild != None:                myQueue.append(node.rchild)if __name__ == '__main__':    """主函数"""    elems = range(10)           #生成十个数据作为树节点    tree = Tree()          #新建一个树对象    for elem in elems:                          tree.add(elem)           #逐个添加树的节点    print '队列实现层次遍历:'    tree.level_queue(tree.root)    print '\n\n递归实现先序遍历:'    tree.front_digui(tree.root)    print '\n递归实现中序遍历:'     tree.middle_digui(tree.root)    print '\n递归实现后序遍历:'    tree.later_digui(tree.root)    print '\n\n堆栈实现先序遍历:'    tree.front_stack(tree.root)    print '\n堆栈实现中序遍历:'    tree.middle_stack(tree.root)    print '\n堆栈实现后序遍历:'    tree.later_stack(tree.root)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

总结：

树的遍历主要有两种，一种是深度优先遍历，像前序、中序、后序；另一种是广度优先遍历，像层次遍历。在树结构中两者的区别还不是非常明显，但从树扩展到有向图，到无向图的时候，深度优先搜索和广度优先搜索的效率和作用还是有很大不同的。 
深度优先一般用递归，广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

我印象中是有递归构造树的方法，却一直想不出该怎么构造。后来仔细想了一下，递归思想有点类似深度优先算法，而树的构造应该是广度优先的。如果用递归的话一定要有个终止条件，例如规定树深等。不然构造出来的树会偏向左单子树或者右单子树。所以一般树的构造还是应该用队列比较好。

以上说的不够严谨，有错误之处，欢迎指正！

转载请注明出处，谢谢！（原文链接：http://blog.csdn.net/bone_ace/article/details/46718683）