Python实现 二叉树遍历六种方式

class TreeNode:
    def __init__(self, elem, left=None, right=None):
        self.val = elem
        self.left = left
        self.right = right

class SStack:
    def __init__(self, max_length=10000):
        self.max_length = max_length
        self.elems = []
    def push(self, val):
        if len(self.elems) > self.max_length:
            print("the stack is fulled")
            return
        self.elems.append(val)
    def is_empty(self):
        return len(self.elems) == 0

    def top(self):
        if self.is_empty():
            return None
        return self.elems[-1]

    def pop(self):
        if self.is_empty():
            return None
        return self.elems.pop()

class queue:
    def __init__(self, max_length=10000):
        self.max_length = max_length
        self.elems = []
    def push(self, val):
        if len(self.elems) > self.max_length:
            return None
        self.elems.append(val)
    def is_empty(self):
        return len(self.elems) == 0

    def pop(self):
        if self.is_empty():
            return None
        return self.elems.pop(0)
        
def preorder(pRoot):
    if pRoot == None:
        return None
    print(pRoot.val)
    preorder(pRoot.left)
    preorder(pRoot.right)
    return pRoot

def inorder(pRoot):
    if pRoot == None:
        return None
    inorder(pRoot.left)
    print(pRoot.val)
    inorder(pRoot.right)
    return pRoot

def postorder(pRoot):
    if pRoot == None:
        return None
    postorder(pRoot.left)
    postorder(pRoot.right)
    print(pRoot.val)

ss = queue()
def level_generate_tree(num):
    if num <= 0:
        return None
    tNode = TreeNode(0)
    ss.push(tNode)
    t = 1
    while t < num:
        root = ss.pop()
        root.left = TreeNode(t)
        ss.push(root.left)
        t += 1
        if t >= num:
            return tNode
        root.right = TreeNode(t)
        ss.push(root.right)
        t += 1
    while not ss.is_empty():
        ss.pop()
    return tNode


def preorder_nonrec(pRoot):
    s = SStack()
    while pRoot is not None or not s.is_empty():
        while pRoot is not None:
            print(pRoot.val)
            s.push(pRoot.right)
            pRoot = pRoot.left
        pRoot = s.pop()

def inorder_nonrec(pRoot):
    s = SStack()
    while pRoot is not None or not s.is_empty():
        while pRoot is not None:
            s.push(pRoot)
            pRoot = pRoot.left
        pRoot = s.pop()
        print(pRoot.val)
        pRoot = pRoot.right

def postorder_nonrec(pRoot):
    s = SStack()
    while pRoot is not None or not s.is_empty():
        while pRoot is not None:
            s.push(pRoot)
            pRoot = pRoot.left if pRoot.left is not None else pRoot.right

        pRoot = s.pop()
        print(pRoot.val)
        if not s.is_empty() and s.top().left == pRoot:
            pRoot = s.top().right
        else:
            pRoot = None
            
    
if __name__ == "__main__":
    pRoot = level_generate_tree(10)
    postorder(pRoot)
    print("=="*20)
    postorder_nonrec(pRoot)