python 二叉树

前两天写了点关于python数据结构的小程序，今天就整个稍微难点的（自己感觉）----- 二叉树。依稀记得当年，师兄教我这个东西，我怎么都感觉别扭，现在自己写出来，才感觉时间过的真快。不废话了，直接上代码：

# !/usr/bin/env python
# -*- coding : utf-8 -*-

class Node:
    def __init__(self, data, root,left, right):
        self.data = data
        self.root = root
        self.left = left
        self.right = right

class BinaryTree:
    
    def __init__(self, root = None):
        self.root = root

    def create(self, pList): #创建二叉树
        #生成父节点
        self.root = Node (pList[0],None,None, None)

        for i in pList[1:]: #使用insert方法帮助创建
            self.insert (i, self.root)

    #由于python表面不支持重载，故采用默认参数
    def insert(self,data,root_node = None):
        if root_node.data == data:  #插入数据与节点数据相等时，直接返回
            return
        if root_node.data > data:   #节点数据大于插入数据
            if root_node.left is None:
                root_node.left = Node(data, root_node, None, None)
            else:
                return self.insert( data,root_node.left)
        if root_node.data < data:   #节点数据小于插入数据
            if root_node.right is None:
                root_node.right = Node(data, root_node, None, None)
            else:
                return self.insert( data,root_node.right)

    def delete(self, data): #删除数据，比其他语言要简单的多
        tmp_node = self.search(data, self.root)
        if tmp_node == self.root:
            tmp_node = None
        else:
            tmp1_node = tmp_node.root   #获得当前节点的父节点，仅需将父节点指向当前节点的引用(left/right)设为None即可
            if tmp1_node.left == tmp_node:
                tmp1_node.left = None
            elif tmp1_node.right == tmp_node:
                tmp1_node.right = None
    
    def search(self, data, root_node = None): #主要为其他函数服务，可返回数据data的节点
        if self.isEmpty():
            print "The BinaryTree is empty!\n The data you want to search is not in this Tree!"
        if root_node.data == data:
            return root_node
        if root_node.data > data:
            if root_node.left is None:
                print "The data you want to search is not in this Tree!"
            else:
                return self.search(data, root_node.left)
        if root_node.data < data:
            if root_node.right is None:
                print "The data you want to search is not in this Tree!"
            else:
                return self.search(data, root_node.right)

    def pre_order(self, root_node = None):  #前序遍历
        if root_node is not None:
            print root_node.data
            self.pre_order(root_node.left)
            self.pre_order(root_node.right)

    def mid_order(self, root_node = None):  #中序遍历
        if root_node is not None:
            self.mid_order(root_node.left)
            print root_node.data
            self.mid_order(root_node.right)       

    def post_order(self, root_node = None): #后序遍历
        if root_node is not None:
            self.post_order(root_node.left)
            self.post_order(root_node.right)
            print root_node.data

    def level_order(self, root_node = None): #层次遍历!!!
        node_list = []
        tmp_node = root_node
        while tmp_node is not None:
            print tmp_node.data
            if tmp_node.left is not None:
                node_list.append(tmp_node.left)
            if tmp_node.right is not None:
                node_list.append(tmp_node.right)
            if len(node_list) == 0:
                tmp_node = None
            else:
                tmp_node = node_list[0]
                del node_list[0]
                

    def isEmpty(self):
        return self.root is None

#主函数测试使用
if __name__ == "__main__":
    BT = BinaryTree()
    BT.create([6,8,4,7,2,0,3,5,1,9])
    BT.insert(20, BT.root)
    BT.insert(19, BT.root)
    BT.insert(21, BT.root)
    BT.insert(17, BT.root)
    BT.insert(24, BT.root)
    BT.insert(15, BT.root)
##    print "pre_order:"
##    BT.pre_order(BT.root)
##    print "mid_order:"
##    BT.mid_order(BT.root)
##    print "post_order:"
##    BT.post_order(BT.root)
    print "level_order:"
    BT.level_order(BT.root)
    BT.delete(20)
    BT.level_order(BT.root)

代码比前面能稍微好点不，至少我加了点注释哈。老实说，二叉树使用递归算法，真算得上逻辑清楚，代码简单，但是递归总有递归的坏处，比如递归层次太深，反而影响程序的运行效率，当然这是题外话。今天的小程序，我用了点小心思，因为前两篇文章中都使用任何模块（也就是import），由于大多数人在二叉树的层次遍历都需要使用一种数据结构-----队列（queue），python中当然也有，就算没有，咱昨天也实现了。只想说，为了不使用import，我选择了python的list（是不是有点作弊的感觉）。写到这，我突然想起了C、C++中二叉树的删除（delete）操作时，又是一身冷汗啊，一般步骤：先删左子树，依次右子树，最后删除当前节点（当然了，递归不可少），这主要是每个节点占据的资源都需要自己手动释放，python实现这个操作，可不只是简单那么一点（自己感觉）。老实说，用惯了指针的人都是大神啊！

刚开始使用博客这个高大上的东西，整的话都不会说了，但愿自己勤而不辍，每天一点点，我倒想看看天道酬勤是个什么境界！！！