二叉树遍历（栈实现）

数据结构学习之二叉树的遍历 Python 实现

---

• 先序遍历
• 中序遍历
• 后续遍历
• 层序遍历

# 构建二叉树
class binTree:
      """
            Created on 2020年10月27日
            Coding by yadon   
      """
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

    # 遍历
    def traverse(self, order=\'preorder\'):
        # 先序遍历
        if order == \'preorder\':
            stack = [self]
            while len(stack):
                node = stack.pop()
                print(node.val)
                if node.right: stack.append(node.right)
                if node.left: stack.append(node.left)
        # 中序遍历
        if order == \'infixorder\':
            """
                中序遍历:
                - 也即右侧退后
            """
            stack = []
            node = self
            while len(stack) or node:
                while node:
                    stack.append(node)
                    node = node.left
                node = stack.pop()
                yield node.val
                node = node.right
        # 后序遍历
        elif order == "postorder":
            stack = [self]
            order = []                  # [修改]order用来记录值而不是node
            while len(stack):
                node = stack.pop()
                order.append(node.val)  # [修改]order用来记录值而不是node
                if node.left: stack.append(node.left)
                if node.right: stack.append(node.right)
            while len(order):
                print(order.pop())      # [修改]order用来记录值而不是node

        # 层序遍历
        elif order == "levelorder":
            cache1 = [self]
            while len(cache1):
                cache0 = []
                for node in cache1:     # 层遍历
                    print(node.val)
                    if node.left: cache0.append(node.left)
                    if node.right: cache0.append(node.right)
                cache1 = cache0
        
    # 从列表创建二叉树(层序遍历顺序，使用 None 占位)
    def createBinTree(L: list):
        if len(L) == 0:
            return None
        
        head = binTree(L[0])                # 使用 L 中第一个元素创建头节点;
        cache1 = [head]                     # 初始化 cache1 缓存
        i = 1                               # L[0] 已使用，从 L[1] 开始遍历
        while i < len(L):                   # 从 1 遍历列表 L
            cache0 = []
            for node in cache1:             # 创建并保存当前层的节点，以备下一层节点的连接
                if node:
                    if i < len(L) and L[i]: node.left = binTree(L[i])
                    i += 1
                    if i < len(L) and L[i]: node.right = binTree(L[i])
                    i += 1
                    cache0.append(node.left)
                    cache0.append(node.right)
            cache1 = cache0
        return head