#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)