python 用栈和队列实现二叉树的深度优先遍历（三种）和广度优先遍历

#coding=utf-8


#自定义队列
class pyqueue():

    def __init__(self, size):
        self.queue = []
        self.size = size
        self.end = -1


    def Size(self):
        return self.size

    def In(self, value):
        if self.end == self.size - 1:
            raise queueexception('isfull')
        else:
            self.queue.append(value)
            self.end += 1


    def Out(self):
        if self.end == -1:
            raise queueexception('isempty')
        else:
            ele = self.queue[0]
            self.queue = self.queue[1:]
            self.end -= 1
            return ele
    def End(self):
        return self.end

    def notempty(self):
        if self.end == -1:
            return False
        else:
            return True


class queueexception(Exception):
    def __init__(self, data):
        self.data = data
    def __str__(self):
        return self.data


class Pystack():
    #类属性
    name = 'leishuxing'
    def __init__(self, size):
        #实例属性
        #Pystack.stack = []
        #Pystack.size = sive
        #Pystack.top = -1 此方法可以定义实例属性但不可没有实例化类前调用
        self.stack = []
        self.size = size
        self.top = -1


    def setsive(self, size):
            self.size = size


    def push(self,value):
        if self.isfull():
            raise stackexpection('stackisfull')
        else:
            self.stack.append(value)
            self.top += 1


    def pop(self):
        if self.isempty():
            raise stackexpection('stackisempty')
        else:
            ele = self.stack.pop()
            self.top -= 1
            return ele

    def Top(self):
        return self.top

    def empty(self):
        self.stack = []
        self.top = -1

    def isfull(self):
        if self.top == self.size - 1:
            return True
        else:
            return False

    def isempty(self):
        if self.top == -1:
            return True
        else:
            return False

    def notempty(self):
        if self.top == -1:
            return False
        else:
            return True


class stackexpection(Exception):
    def __init__(self, data):
        self.data = data
    def __str__(self):
        return self.data

#用列表构建树
G = ['G',['H','I']]#每个列表都包含该元素和该元素的自成员
H = ['H',[]]

#用类构建二叉树
class Btree():
    def __init__(self, value):
        self.left = None
        self.data = value
        self.right = None


    def insertleft(self,value):
        self.left = Btree(value)
        return self.left


    def insertright(self, value):
        self.right = Btree(value)
        return self.right


    def show(self):
        print self.data




#用栈实现树的遍历，终止条件当前节点为空并且栈为空，
#1、当前节点处理（1）处理该节点 （2）将该节点放入栈（3）处理左节点）
#左节点为空，处理右节点
def pre_stack(root):
    if root == None:
        return
    node = root
    mystack = Pystack(20)#栈的长度
    while node or mystack.notempty():
        while node:
            node.show()
            mystack.push(node)
            #print type(mystack.pop())
            node = node.left
        node = mystack.pop()
        node = node.right


def middle_stack(root):
    if root == None:
        return
    node = root
    mystack = Pystack(20)
    while node or mystack.notempty():
        while node:
            mystack.push(node)
            node = node.left
        node = mystack.pop()
        node.show()
        node = node.right


def later_stack(root):
    if root == None:
        return
    node = root
    mystack1 = Pystack(20)
    mystack2 = Pystack(20)
    mystack1.push(node)
    while mystack1.notempty():
        node = mystack1.pop()
        if node.left:
            mystack1.push(node.left)
        if node.right:
            mystack1.push(node.right)
        mystack2.push(node)#将访问次序按反存在mystack2中
    while mystack2.notempty():
        print mystack2.pop().data
    #mystack2.stack.reverse()
    #for ii in mystack2.stack:
    #    print ii.data


def level_queue(root):
    if root == None:
        return
    node = root
    myqueue = pyqueue(20)#设置队列长度为20
    myqueue.In(node)
    while myqueue.notempty():
        node = myqueue.Out()
        node.show()
        if node.left:
            myqueue.In(node.left)
        if node.right:
            myqueue.In(node.right)




if __name__ == '__main__':
    root = Btree("root")
    A = root.insertleft('A')
    B = root.insertright('B')
    C = A.insertleft('C')
    D = C.insertright('D')
    E = B.insertleft('E')
    print 'preorder'
    pre_stack(root)
    print 'inorder'
    middle_stack(root)
    print 'postorder'
    later_stack(root)
    print 'levelorder'
    level_queue(root)