二叉树一点实现python版

#encoding=utf-8
class TreeNode:
    parent,leftChild,rightChild,data=None,None,None,0
    def __init__(self,data):
        self.parent,self.leftChild,self.rightChild,self.data=None,None,None,data
class BinaryTree:
    root=None
    def __init__(self,data):
        self.root=TreeNode(data)
    def insertValue(self,beginNode,data):
        self.add(beginNode,TreeNode(data))
    def add(self,beginNode,inNode):
        if beginNode==None:
            raise NameError,"beginNode is None"
        else:
            if beginNode.data<inNode.data:
                if beginNode.rightChild==None:
                    inNode.parent=beginNode
                    beginNode.rightChild=inNode
                else:
                    self.add(beginNode.rightChild,inNode)
            else:
                if beginNode.leftChild==None:
                    inNode.parent=beginNode
                    beginNode.leftChild=inNode
                else:
                    self.add(beginNode.leftChild,inNode)
    def maxValue(self,beginNode):
        if beginNode.rightChild==None:
            return beginNode.data
        else:
            return self.maxValue(self,beginNode.rightChild)
    def maxDepth(self,beginNode):
        if beginNode==None:
            return 0
        else:
            return max(self.maxDepth(beginNode.rightChild),self.maxDepth(beginNode.leftChild))+1
    def judgeDirction(self,beginNode,searchedNode):
        if searchedNode==beginNode:
            Direction="OnlySelf"
        elif searchedNode==beginNode.leftChild:
            Direction="Left"
        elif searchedNode==beginNode.rightChild:
            Direction="Right"
        else: Direction="Up"
        return Direction
    def nextNode(self,beginNode):


        returnNode,Direction=self.nextNodeByDirection(beginNode,"OnlySelf")
        if Direction=="AllOver":
            return None
        """
         else:
            returnNode,Direction=self.nextNodeByDirection(searchedNode,"Left")
        Direction=self.judgeDirction(beginNode,returnNode)
        """
        return returnNode
    def nextNodeByDirection(self,beginNode,searchedDirection="OnlySelf"):
        """
        beginNode：求beginNode的下一个节点
        searchedDirection:表示已经搜索过的方向：OnlySelf表示什么也没有搜索，Left,表示已经搜索了左孩子节点，Right表示已经
                          搜索右子树
        思路：
        1.如果什么都没有搜索，则返回左孩子，如果左孩子为空，进行步骤2
        2.搜索右孩子点，返回右孩子，如果右孩子为空，进入步骤3
        3.获取节点A的父节点parent,如果节点A是父节点parent的左孩子的话，设置已经搜索了"Left",设置parent节点为当前节点
        此时就可以进入步骤2，如果节点A是父节点parent的右孩子的话，设置已搜索方法为"Right",设置parent节点为当前节点，
        再进入节点3


        什么时候可以退出呢？当返回方向为"AllOver"且返回的节点为None时，就可以退出了
        """
        if searchedDirection=="OnlySelf":
            if  not beginNode.leftChild:
                return self.nextNodeByDirection(beginNode,"Left")
            else:
                return beginNode.leftChild,searchedDirection
        elif searchedDirection=="Left":
            rightChildNode=beginNode.rightChild
            if not rightChildNode:
                return self.nextNodeByDirection(beginNode,"Right")
            else:
                return rightChildNode,searchedDirection
        else:
            parentNode=beginNode.parent
            if not parentNode:
                return None,searchedDirection
            else:
                if parentNode.leftChild==beginNode:
                    return self.nextNodeByDirection(parentNode,"Left")
                else:
                    return self.nextNodeByDirection(parentNode,"Right")
    def priorNode(self,beginNode):
        parentNode=beginNode.parent
        if parentNode is None:
            return None
        else:
            if  parentNode.leftChild == beginNode:
                return parentNode
            else:
                leftChildNode=parentNode.leftChild
                if leftChildNode is None:
                    return parentNode
                else:
                    return self.FindLastNodeOfTree(leftChildNode)
    def FindLastNodeOfTree(self,Treeroot):
        """
        # 找到树的最后一个节点
        Treeroot:树的根节点
        """
        rightChildNode=Treeroot.rightChild
        if  not rightChildNode:
            leftChildNode=Treeroot.leftChild
            if not leftChildNode:
                return Treeroot
            else:
                return self.FindLastNodeOfTree(leftChildNode)
        else:
            return self.FindLastNodeOfTree(rightChildNode)
    def FindTheFirstProcessor(self,Treeroot):
        if not Treeroot.leftChild:
            return Treeroot
        else:
            return self.FindTheFirstProcessor(Treeroot.leftChild)
    def processor(self,searchNode):
        """
        寻找searchNode节点的直接前驱节点
        """
        searchLeft=searchNode
        while True:
            leftChildNode=searchLeft.leftChild
            if not leftChildNode:
                break
            searchLeft=leftChildNode
        if searchLeft==searchNode:
            return None
        else:
            return self.FindTheLastSuccssor(self,searchLeft)
    def FindTheLastSuccssor(self,searchNode):
        """
        查找前序遍历情况下，以searchNode为根节点的树的最后一个节点
        """
        if self.isLeaf(searchNode):
            return searchNode
        else:
            if not searchNode.rightChild :
                return searchNode
            else:
                return self.FindTheLastSuccssor(searchNode.rightChild)
    def isLeaf(self,judgeNode):
        return   (judgeNode.leftChild is None  and  judgeNode.rightChild is None)
    def successor(self,searchNode):
        """
        寻找searchNode节点的直接后继节点
        """
        #如果是非叶子节点
        if not  self.isLeaf(searchNode):
            rightChildNode=searchNode.rightChild
            if not rightChildNode:
                parentNode=searchNode.parent
                if not parentNode:
                    return None
                else:
                    if parentNode.rightChild==searchNode:
                        return self.successor(parentNode)
                    else:
                        return parentNode
            else:
                return self.FindTheFirstProcessor(rightChildNode)


        #如果是叶子节点
        else:
            parentNode=searchNode.parent
            if not parentNode:
                return None
            else:
                #如果是左孩子节点
                if parentNode.leftChild==searchNode:
                    return parentNode
                #如果是右孩子节点,则返回searchNode的祖父节点
                else:
                    anscetorNode=parentNode.parent
                    if not anscetorNode:
                        return None
                    else:
                        return anscetorNode
    def successorByDirection(self,searchNode,Direction="OnlySelf"):
        


    def printTree(self,beginNode):
        """
        # 中序遍历
        """
        searchNode=None
        print beginNode.data,
        searchNode=beginNode
        while True:
            searchNode=self.nextNode(searchNode)
            if not  searchNode:
                break
            print searchNode.data,
    def reversePritTree(self):
        """
        逆中序遍历
        """
        theLastNode=self.FindLastNodeOfTree(self.root)
        searchNode=theLastNode
        print searchNode.data,
        while True:
            searchNode=self.priorNode(searchNode)
            if not searchNode:
                break
            else:
                print searchNode.data,
    def FirstPrintTree(self,Treeroot):
        theFirstProcess=self.FindTheFirstProcessor(Treeroot)
        print theFirstProcess.data,
        while True:
            theFirstProcess=self.successor(theFirstProcess)
            if not theFirstProcess:
                break
            else:
                print theFirstProcess.data,
    def FirstReversePrintTree(self,Treeroot):
        theLastSuccess=self.FindTheLastSuccssor(Treeroot)
        print theLastSuccess.data,
        while True:
            theLastSuccess=self.processor(theLastSuccess)
            if not  theLastSuccess:
                break
            else:
                print theLastSuccess.data,






if __name__=='__main__':
    ds=[5,6,4,10,8,7,2]
    BTree=BinaryTree(ds[0])


    for i in ds[1:]:
        BTree.insertValue(BTree.root,i)
    BTree.printTree(BTree.root)
    #print BTree.root.data
    print
    BTree.reversePritTree()
    print
    BTree.FirstPrintTree(BTree.root)
    print
    BTree.FirstReversePrintTree(BTree.root)

今天先写到这里吧。。晕死了，想了一下午了。。。改了好多次。。好想念VS。。。。其余工具调试起来真TMD的不爽。。。
。。。再了一下。想了一下午的问题。为什么说起来就是这么简单呢。。还是说我本来就很水呢。。哎。。。。。。。。。。。。。。。。。。。。