二叉树的非递归后序遍历

第四章-二叉树的非递归后序遍历
‘’’
注意：
1.本博客仅供参考交流使用，请读者务必自行实践，切勿生搬硬套
2.由于笔者水平有限，若文中有错误或者可以改进之处，欢迎在评论区指出
题目
‘’’
Description

给定一组输入数据，要求按照该输入数据构造一颗二叉树并且使用非递归的后序遍历算法遍历该二叉树。PS：不能使用递归后序遍历算法，必须是非递归。

Input
按照满二叉树的对应位置(即将输入的元素层序按从根到叶节点，同层按从左到右输入)输入一串数据，例如：1 2 3 # 5 6 # # #10 # # 13，以空格分开，其中#号代表对应的节点处为空，其对应的二叉树为：

这个题没啥好说的，可以参考我之前写的先序输出，道理一样
先序排列

class Node(object):
    def __init__(self, lchild=None, rchild=None, elem=0):
        self._elem, self._lchild, self._rchild = elem, lchild, rchild

    @property
    def elem(self):
        if self._elem is '#':
            return None
        return self._elem

    @property
    def lchid(self):
        return self._lchild

    @property
    def rchild(self):
        return self._rchild

    @elem.setter
    def elem(self, elem):
        self._elem = elem

    @lchid.setter
    def lchild(self, lchild):
        self._lchild = lchild

    @rchild.setter
    def rchild(self, rchild):
        self._rchild = rchild


class BinTree(object):
    def __init__(self, elem=None):
        if elem is not None:
            self.root = Node(None, None, elem)
        else:
            self.root = None

    def append(self, elem):
        if self.root is None:
            self.root = Node(None, None, elem)
        else:
            queue = [self.root]
            while len(queue) > 0:
                cur = queue.pop(0)
                if cur.lchild is None:
                    cur.lchild = Node(None, None, elem)
                    return
                elif cur.rchild is None:
                    cur.rchild = Node(None, None, elem)
                    return
                else:
                    queue.append(cur.lchild)
                    queue.append(cur.rchild)

    def layer_order(self):
        if self.root is None:
            print('None')
        else:
            queue = [self.root]
            while queue:
                node = queue.pop(0)
                print(node.elem)
                if node.lchild is not None:
                    queue.append(node.lchild)
                if node.rchild is not None:
                    queue.append(node.rchild)

    def pre_order(self):
        if self.root is None:
            return []
        else:
            stack = [self.root]
            result = []
            while stack:
                cur = stack.pop()
                if cur and cur.elem:
                    result.append(cur.elem)
                    stack.append(cur.rchild)
                    stack.append(cur.lchild)
            return result

    def late_order(self):
        if self.root is None:
            return []
        else:
            stack = [self.root]
            result = []
            while stack:
                cur = stack.pop()
                if cur and cur.elem:
                    stack.append(cur.lchild)
                    stack.append(cur.rchild)
                    result.append(cur.elem)
            result.reverse()
            return result


MyTree = BinTree()
temp_list = list(input().split(" "))
for i in range(len(temp_list)):
    MyTree.append(temp_list[i])
# answer = list(map(int, MyTree.pre_order()))
answer = MyTree.late_order()
for i in range(len(answer)):
    print(answer[i])