python BinaryTree

#-------------------------------------------------------------------------------
# Name:        BinaryTree
# Purpose:      普通二叉树，可以构建最大树和最大堆
#
# Author:      M.E.Liu
#
# Created:     08/07/2015
# Copyright:   (c) M.E.Liu 2015
# Licence:     <Artificial Intelligence Lab of HUST>
#-------------------------------------------------------------------------------


def swap(a,b):
    key = a
    a = b
    b = key
    return a,b

class BinaryTreeNode(object):
    __slots__ = ['data', 'left', 'right']

    def __init__(self, data=0, left=0, right=0):
        self.data = data
        self.left = left
        self.right = right

    def __getitem__(self, key):
        return self.left if key == 0 else self.right

    def __setitem__(self, key, data):
        if(key==0):
            self.left = data
        elif(key==1):
            self.right = data

class BinaryTree(object):
    __slots__ = ['root', 'count', 'height']

    def __init__(self,root=0,count=0,height=0):
        self.root = root
        self.count = 0  #节点数目
        self.height = 0 #树高度

    def __del__(self):  #销毁函数
        pass

    def findNode(self,treenode,data):#查找节点
        if not treenode:
            return
        if treenode.data==data:
            return treenode
        else:
            treenodeLeft = self.findNode(treenode.left,data)
            treenodeRight = self.findNode(treenode.right,data)
            return treenodeLeft if not treenodeLeft else treenodeRight

    def findParent(self,treenode,data):#查找节点的parent--有待于优化
        if not treenode:
            return
        if self.childCount(treenode)=='twins':
            if treenode.right.data==data or treenode.left.data==data:
                return treenode
            else:
                treenodeLeft = self.findParent(treenode.left,data)
                treenodeRight = self.findParent(treenode.right,data)
                return treenodeLeft if treenodeLeft else treenodeRight
        elif self.childCount(treenode) is 'left' or 'right':
            node = treenode.left if treenode.left else treenode.right
            if node.data==data:
                return treenode
            else:
                return self.findParent(node,data)
        else:
            return

    def findLeaf(self,treenode):#显示叶节点
        if not treenode:
            return
        if self.childCount(treenode)=='none':
            print treenode.data
        else:
            self.findLeaf(treenode.left)
            self.findLeaf(treenode.right)

    def create(self):#人工输入构建BinaryTree
        temp = input('enter a value:')
        if temp is 99:
            return
        treenode = TreeNode(data=temp)
        if not self.root:
            self.root = treenode
        treenode.left = self.create()
        treenode.right = self.create()
        return treenode

    def nodeCount(self,treenode):#计算节点数目
        if treenode:
            self.count += 1
            self.nodeCount(treenode.left)
            self.nodeCount(treenode.right)

    def preOrder(self,treenode):#前序遍历
        if not treenode:
            return
        print treenode.data
        self.preOrder(treenode.left)
        self.preOrder(treenode.right)

    def midOrder(self,treenode):#中序遍历
        if not treenode:
            return
        self.midOrder(treenode.left)
        print treenode.data
        self.midOrder(treenode.right)

    def aftOrder(self,treenode):#后序遍历
        if not treenode:
            return
        self.aftOrder(treenode.left)
        self.aftOrder(treenode.right)
        print treenode.data

    def childCount(self,treenode):#判断节点有无孩子
        if not treenode.left and not treenode.right:
            return 'none'
        elif not treenode.left:
            return 'right'
        elif not treenode.right:
            return 'left'
        else:
            return 'twins'

    def MaxHeap(self,treenode): #调整为最大堆--有待于优化
        if not treenode is 0:
            return
        if self.childCount(treenode)=='none':
            return
        elif self.childCount(treenode)== 'left' or 'right':
            node = treenode.left if treenode.left else treenode.right
            if treenode.data<node.data:
                treenode.data,node.data = swap(treenode.data,node.data)
            self.MaxHeap(node)
        else:
            if treenode.right.data>treenode.left.data and treenode.data<treenode.right.data:
                treenode.data,treenode.right.data = swap(treenode.data,treenode.right.data)
            elif treenode.right.data<treenode.left.data and treenode.data<treenode.left.data:
                treenode.data,treenode.left.data = swap(treenode.data,treenode.left.data)
            self.MaxHeap(treenode.left)
            self.MaxHeap(treenode.right)

    def getHeight(self,treenode):   #获取节点距离叶子高度
        if not treenode:
            return 0
        elif self.childCount(treenode)=='none':
            return 1
        left = self.getHeight(treenode.left)
        right = self.getHeight(treenode.right)
        return left+1 if left>right else right+1

    def BuildMaxTree(self,treenode):#构建最大数
        if not treenode:
            return
        self.BuildMaxTree(treenode.left)
        self.BuildMaxTree(treenode.right)
        self.MaxHeap(treenode)


#Example
def main():
    n10 = BinaryTreeNode(10,0,0)
    n9 = BinaryTreeNode(9,0,0)
    n3 = BinaryTreeNode(3,n9,n10)
    n8 = BinaryTreeNode(8,0,0)
    n14 = BinaryTreeNode(14,0,0)
    n7 = BinaryTreeNode(7,0,0)
    n16 = BinaryTreeNode(16,n7,0)
    n2 = BinaryTreeNode(2,n14,n8)
    n1 = BinaryTreeNode(1,n2,n16)
    root = BinaryTreeNode(4,n1,n3)

    bt = BinaryTree(root)
    print bt.findParent(bt.root,n3.data).data

    pass

if __name__ == '__main__':
    main()