二叉树的先序遍历

Description

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

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

PS：遍历输出时所有空节点均不输出；树有可能为空(输入为一个"#")。

Output
输出先序遍历的结果。

Sample Input 1

12 11 5 # # 17 16 # # # # 19 # 18
Sample Output 1

12
11
5
17
19
16
18

参考我另外一篇博客：
构造二叉树并实现访问操作

不同的就是多了一个pre_order
这里使用栈来实现先序，不难理解，读者自行阅读即可

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


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.pre_order()
for i in range(len(answer)):
    print(answer[i])