Python实现二叉树

二叉树的性质什么的在这就不多说了，相信既然想代码实现，就已经了解了这些基本的东西。

直接上代码：

1.代码的目录结构

2.定义树结点类的模块：Node.py

class Node(object):
    def __init__(self, elem=-1, lchild=None, rchild=None):
        self.elem = elem
        self.lchild = lchild
        self.rchild = rchild

3.创建和遍历二叉树的模块：Tree.py

from binarytree.Node import *


class Tree(object):
    """tree class"""

    def __init__(self):
        self.root = Node()
        self.myQueue = []

    def add(self, elem):
        """add tree Node"""
        node = Node(elem)
        if self.root.elem == -1:  # 如果树是空的，则对根节点赋值
            self.root = node
            self.myQueue.append(self.root)
        else:
            treeNode = self.myQueue[0]  # 此结点的子树还没有齐
            if treeNode.lchild is None:
                treeNode.lchild = node
                self.myQueue.append(treeNode.lchild)
            else:
                treeNode.rchild = node
                self.myQueue.append(treeNode.rchild)
                self.myQueue.pop(0)  # 如果该结点存在右子树，将此结点丢弃

    def preorder_recurrence(self, root):
        """利用递归实现先序遍历"""
        if root is None:
            return []

        res = []
        res.append(root.elem)
        res += self.preorder_recurrence(root.lchild)
        res += self.preorder_recurrence(root.rchild)
        return res

    def inorder_recurrence(self, root):
        """利用递归实现中序遍历"""
        if root is None:
            return []

        res = []
        res += self.inorder_recurrence(root.lchild)
        res.append(root.elem)
        res += self.inorder_recurrence(root.rchild)
        return res

    def postorder_recurrence(self, root):
        """利用递归实现中序遍历"""
        if root is None:
            return []

        res = []
        res += self.postorder_recurrence(root.lchild)
        res += self.postorder_recurrence(root.rchild)
        res.append(root.elem)
        return res

    def preorder_stack(self, root):
        """利用堆栈实现树的先序遍历"""
        if root is None:
            return
        res = []
        myStack = []
        node = root
        while node or myStack:
            while node:  # 从根节点开始，一直找它的左子树
                res.append(node.elem)
                myStack.append(node)
                node = node.lchild
            node = myStack.pop()  # while结束表示当前节点node为空，即前一个节点没有左子树了
            node = node.rchild  # 开始查看它的右子树
        return res

    def inorder_stack(self, root):
        """利用堆栈实现树的中序遍历"""
        if root is None:
            return
        res = []
        myStack = []
        node = root
        while node or myStack:
            while node:  # 从根节点开始，一直找它的左子树
                myStack.append(node)
                node = node.lchild
            node = myStack.pop()  # while结束表示当前节点node为空，即前一个节点没有左子树了
            res.append(node.elem)
            node = node.rchild  # 开始查看它的右子树
        return res

    def postorder_stack(self, root):
        """利用堆栈实现树的后序遍历"""
        if root is None:
            return
        res = []
        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中的元素出栈，即为后序遍历次序
            res.append(myStack2.pop().elem)
        return res

    def level_queue(self, root):
        """利用队列实现树的层次遍历"""
        if root is None:
            return
        res = []
        myQueue = []
        node = root
        myQueue.append(node)
        while myQueue:
            node = myQueue.pop(0)
            res.append(node.elem)
            if node.lchild is not None:
                myQueue.append(node.lchild)
            if node.rchild is not None:
                myQueue.append(node.rchild)
        return res

4.测试代码模块：test.py

from binarytree.Tree import *

if __name__ == '__main__':
    num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    tree = Tree()
    for i in num:
        tree.add(i)
    print('-'*10)
    print(tree.preorder_recurrence(tree.root))
    print(tree.inorder_recurrence(tree.root))
    print(tree.postorder_recurrence(tree.root))
    print('-' * 10)
    print(tree.preorder_stack(tree.root))
    print(tree.inorder_stack(tree.root))
    print(tree.postorder_stack(tree.root))