二叉树遍历（非递归版）——python

二叉树的遍历分为广度优先遍历和深度优先遍历

• 广度优先遍历(breadth first traversal)：又称层次遍历，从树的根节点(root)开始，从上到下从从左到右遍历整个树的节点。

• 深度优先遍历(depth first traversal)：对于一颗二叉树，深度优先遍历是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。深度优先遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder）：根节点->左子树->右子树，中序遍历（inorder）：左子树->根节点->右子树，和后序遍历（postorder）：左子树->右子树->根节点。这三种都是递归方式实现对一整个二叉树遍历的哦。

• 代码（非递归版）

• class TreeNode:
      def __init__(self, x):
          self.val = x
          self.left = None
          self.right = None
  class Trees:
      #根据前序和中序列表来重建二叉树
      def reConstructBinaryTree(self, pre, tin):
          # write code here
          if len(pre) == 0:
              return None
          if len(pre) == 1:
              return TreeNode(pre[0])
          else:
              flag = TreeNode(pre[0])
              flag.left = self.reConstructBinaryTree(pre[1:tin.index(pre[0])+1],tin[:tin.index(pre[0])])
              flag.right = self.reConstructBinaryTree(pre[tin.index(pre[0])+1:],tin[tin.index(pre[0])+1:])
          return flag
      #前序遍历
      def preOrder(self, root):
          if root == None:
              return
          stack = []
          result = []
          node = root
          while node or stack:
              while node:
                  # 从根节点开始，一直找它的左子树
                  result.append(node.val)
                  stack.append(node)
                  node = node.left
              # while结束表示当前节点node为空，即前一个节点没有左子树了
              node = stack.pop()
              # 开始查看它的右子树
              node = node.right
          return result
      #中序遍历
      def inOrder(self,root):
          if root == None:
              return
          stack = []
          result = []
          node = root
          while node or stack:
              while node:
                  #　从根节点开始，一直找到左子树
                  stack.append(node)
                  node = node.left
              # while结束表示当前节点node为空，即前一个节点没有左子树了
              node = stack.pop()
              result.append(node.val)
              node = node.right
          return result
      #后序遍历
      def postOrder(self, root):
          if root == None:
              return
          stack = []
          result = []
          node = root
          while node or stack:
              while node:
                  # 从根节点开始，一直找它的右子树
                  result.insert(0,node.val)
                  stack.append(node)
                  node = node.right
              # while结束表示当前节点node为空，即前一个节点没有右子树了
              node = stack.pop()
              # 开始查看它的左子树
              node = node.left
          return result
      #广度优先遍历(即层次遍历)
      def breadthFirstTravel(self,root):
          if root == None:
              return
          queue = [root]
          result = []
          while queue:
              node = queue.pop(0)
              result.append(node.val)
              if node.left:
                  queue.append(node.left)
              if node.right:
                  queue.append(node.right)
          return result   
      
  pre = [1,2,4,8,5,3,6,7]   
  tin = [8,4,2,5,1,6,3,7]
  pos = [8,4,5,2,6,7,3,1]
  
  demo = Trees()
  Nroot = demo.reConstructBinaryTree(pre,tin)
  print(demo.preOrder(Nroot))
  print(demo.inOrder(Nroot))
  print(demo.postOrder(Nroot))
  print(demo.breadthFirstTravel(Nroot))

   前序和中序遍历的结构基本相似，前序遍历的顺序是"根左右"，从根节点一直向左找到最左的叶子结点，再依次从下往上路径上结点的右子树。

• 中序遍历的顺序是“左根右”，从根节点一直向左找到最左的叶子结点，先访问其右子树，再一次沿着路径向上到根节点，之后是根几点的右子树。
• 后续遍历的顺序是“左右根”，不好遍历，从左节点到右节点是“跳过去的”，换种方法，先把遍历顺序反过来——“根右左”，这种顺序熟悉，就把前序遍历的node.left与node.right交换就可以了，得到的遍历顺序表与后续遍历的顺序表应该是相反的，故可以在列表增加元素的时候反过来或者最后使用list.reverse().
• 广度优先遍历就是从上往下，从左往右打印，利用队列先入先出，若把同一行的结点放在一起，在里边需要再增加一个临时列表。

 

参照链接：

　　https://blog.csdn.net/John_xyz/article/details/79342846

　　https://blog.csdn.net/zzfightingy/article/details/86742755

转载于:https://www.cnblogs.com/fighting25/p/11430473.html