二叉树非递归

题目

iterative的方法构造二叉树

思路

1.构造二叉搜索树，先创建一个新的节点，如果没有根节点，则创建一个根节点，然后在创建一个当前节点和父节点，用父节点记录当前节点的位置，然后判断插入的节点值和当前节点值的大小，若当前节点为空，则插入。

2. 查找功能，先从根节点开始，然后判断大小，若大，则去找右节点，若小，则去找左节点。

3.中序遍历，从根节点开始，一直探索左孩子，当遇到空节点时，就弹出栈，再去访问他的右节点。

4.先序遍历，从根节点开始，先入栈，栈不为空时，在出栈，打印，然后先进右节点，再进左节点。

5.后序遍历，从根节点开始，并给他附上一个flag初始为False，然后出栈，如果flag是False，则不打印，然后再让他入栈，flag更新为True，再入右节点，再入左节点。

6.层次遍历，创建一个两个栈，一个当前栈，和一个下一层的栈，访问当前栈的node时，把下一层的节点放到下一层栈中，当当前栈没有节点时，退出，把下一层栈的node赋给当前栈。

代码

class Node:
  slots = '_item','_left','_right'
  def __init__(self,item,left=None,right=None):
    self._item = item
    self._left = left
    self._right = right
  
class binary_search_tree:
  def __init__(self,root=None):
    self.root = root
  
  def add(self,value):
    new_node = Node(value)
    if self.root is None:
      self.root = new_node
      return
    
    current = self.root
    parent = None
    while True:
      parent = current
      if value < current._item:
        current = current._left
        if current is None:
          parent._left = new_node
          return
      else:
        current = current._right
        if current is None:
          parent._right = new_node
          return


  def get(self,value):
    node = self.root
    while node is not None:
      if node._item == value:
        return node._item
      if node._item < value:
        node = node._left
      else:
        node = node._right
    return None


  def print_inorder(self):
    node = self.root
    stack = []
    while True:
      while node is not None:
        stack.append(node)
        node = node._left
      
      if len(stack) == 0:
        return
      
      node = stack.pop()
      print('[',node._item,']',end='')
      node = node._right
  
  def print_preorder(self):
    node = self.root
    stack = []
    stack.append(node)
    while stack:
       node = stack.pop()
       print('[',node._item,']',end='')
       if node is not None :
         if node._right:
          stack.append(node._right)
         if node._left:
          stack.append(node._left)

  def print_posorder(self):
    node = self.root
    stack = [(node,False)]
    while stack:
      node,visit = stack.pop()
      if node:
        if visit:
          print('[',node._item,']',end='')
        else:
          stack.append((node,True))
          stack.append((node._right,False))
          stack.append((node._left,False))

  def print_levelorder(self):
    node = self.root
    level = [node]
    ret = []
    while level:
      current_level = []
      next_level = []
      for node in level:
        current_level.append(node._item)
        if node._left:
          next_level.append(node._left)
        if node._right:
          next_level.append(node._right)
      ret.append(current_level)
      level = next_level
    #ret = ret[::-1]  
    return ret

  def print_levelorderz(self):
    node = self.root
    level = [node]
    ret = []
    flag = 1
    while level:
      current_level = []
      next_level = []
      for i in range(len(level)):
        node = level.pop()
        if flag == -1:
          current_level.append(node._item)
          if node._right:
            next_level.append(node._right)
          if node._left:
            next_level.append(node._left)
        if flag == 1:
          current_level.append(node._item)
          if node._left:
            next_level.append(node._left)
          if node._right:
            next_level.append(node._right)
      ret.append(current_level)
      level = next_level
      flag = -flag
    return ret