python实现二叉树后序遍历

import queue

class Node:
    def __init__(self, key, value):
        self.right = None
        self.left = None
        self.key = key
        self.value = value


class Tree:
    def __init__(self):
        self.root = None
        self.n = 0
        super(Tree, self).__init__()
        self.q = queue.Queue()


    def put(self, key, value):
        # Tree.putx 最终返回的还是self.root
        self.root = Tree.putx(self.root, key, value)

    @staticmethod
    def putx(node, key, value):  #
        if node is None:
            # 找到插入的位置
            # 如果传递的节点None, 则返回一个新的节点对象
            return Node(key, value)

        if Tree.compare(node.key, key) < 0:
            # 如果新的key，比node.key小, 则调用putx方法，继续判断node.left节点， 如果node.left 为None 则插入节点，
            # 否则返回的是node.left 本身，从而不改变树的结构
            node.left = Tree.putx(node.left, key, value)
        elif Tree.compare(node.key, key) > 0:
            # 如果新的key，比node.key大, 则调用putx方法，继续判断node.right节点
            node.right = Tree.putx(node.right, key, value)
        else:
            # 如果相等则修改值
            node.value = value

        # 返回当前处理的结点
        return node

    # 循环方式实现
    # def get(self, key):
    #
    #     temp = self.root
    #
    #     while temp is not None:
    #         check = Tree.compare(temp.key, key)
    #         if check < 0:
    #             temp = temp.left
    #         elif check > 0:
    #             temp = temp.right
    #         else:
    #             return temp.value
    #     return None

    def get(self, key):
        return Tree.getx(self.root, key)

    @staticmethod
    def getx(node, key):
        if node is None:
            return None
        if Tree.compare(node.key, key) < 0:
            value = Tree.getx(node.left, key)
        elif Tree.compare(node.key, key) > 0:
            value = Tree.getx(node.right, key)
        else:
            return node.value
        return value

    @staticmethod
    def compare(key1, key2):
        if key1 > key2:
            return -1
        elif key1 < key2:
            return 1
        else:
            return 0

    @property
    def size(self):
        return self.n

    def delete(self, key):
        self.root = Tree.deletex(self.root, key)

    @staticmethod
    def deletex(node, key):
        if node is None:
            return None
        if Tree.compare(node.key, key) < 0:
            node.left = Tree.deletex(node.left, key)
        elif Tree.compare(node.key, key) > 0:
            node.right = Tree.deletex(node.right, key)
        else:
            temp = node
            temp2 = node.right
            while temp2 is not None and temp2.left is not None:
                temp = temp2
                temp2 = temp2.left
            temp.left = None
            temp2.left = node.left
            temp2.right = node.right
            node = temp2
        return node

    def min(self):
        return Tree.minx(self.root).value

    @staticmethod
    def minx(node):
        if node.left is None:
            return node
        else:
            return Tree.minx(node.left)

    def max(self):
        return Tree.maxx(self.root).value

    @staticmethod
    def maxx(node):
        if node.right is None:
            return node
        else:
            return Tree.minx(node.right)

    @staticmethod
    def traverse(q, node):  # 后序遍历

        if node.left is not None:
            Tree.traverse(q, node.left)
        if node.right is not None:
            Tree.traverse(q, node.right)
        if node is None:
            return
        q.put(node)

    def __iter__(self):
        Tree.traverse(self.q, self.root)
        return self

    def __next__(self):
        if self.q.empty():
            Tree.traverse(self.q, self.root)
            raise StopIteration
        else:
            return self.q.get()


if __name__ == '__main__':
    tree = Tree()
    tree.put("a", 1)
    tree.put("b", 2)
    tree.put("1", 4)
    tree.put("0", 4)
    tree.put("2", 4)
    tree.put("3", 4)

    for i in tree:
        print(i.key)