class Node (object):
  def __init__ (self, data):
    self.data = data
    self.lchild = None
    self.rchild = None

class Tree (object):
  def __init__ (self):
    self.root = None

  # search for a node with a key
  def search (self, key):
    current = self.root
    while (current != None) and (current.data != key):
      if (key < current.data):
        current = current.lchild
      else:
        current = current.rchild
    return current

  # insert a node in a tree
  def insert (self, val):
    newNode = Node (val)

    if (self.root == None):
      self.root = newNode
    else:
      current = self.root
      parent = self.root
      while (current != None):
        parent = current
	if (val < current.data):
	  current = current.lchild
	else:
	  current = current.rchild
      if (val < parent.data):
        parent.lchild = newNode
      else:
        parent.rchild = newNode

  # in order traversal - left, center, right
  def inOrder (self, aNode):
    if (aNode != None):
      self.inOrder (aNode.lchild)
      print (aNode.data)
      self.inOrder (aNode.rchild)

  # pre order traversal - center, left, right
  def preOrder (self, aNode):
    if (aNode != None):
      print (aNode.data)
      self.preOrder (aNode.lchild)
      self.preOrder (aNode.rchild)

  # post order traversal - left, right, center
  def postOrder (self, aNode):
    if (aNode != None):
      self.postOrder (aNode.lchild)
      self.postOrder (aNode.rchild)
      print (aNode.data)

  # delete a node with a given key
  def delete (self, key):
    deleteNode = self.root
    parent = self.root
    isLeft = False

    # if empty tree
    if (deleteNode == None):
      return False

    # find the delete node
    while (deleteNode != None) and (deleteNode.data != key):
      parent = deleteNode
      if (key < deleteNode.data):
        deleteNode = deleteNode.lchild
        isLeft = True
      else:
        deleteNode = deleteNode.rchild
	isLeft = False
    
    # if node not found
    if (deleteNode == None):
      return False

    # delete node is a leaf node
    if (deleteNode.lchild == None) and (deleteNode.rchild == None):
      if (deleteNode == self.root):
        self.root = None
      elif (isLeft):
        parent.lchild = None
      else:
        parent.rchild = None

    # delete node is a node with only left child
    elif (deleteNode.rchild == None):
      if (deleteNode == self.root):
        self.root = deleteNode.lchild
      elif (isLeft):
        parent.lchild = deleteNode.lchild
      else:
        parent.rchild = deleteNode.lchild

    # delete node is a node with bothleft and right children
    else:
      # find delete node's successor and successor's parent nodes
      successor = deleteNode.rchild
      successorParent = deleteNode

      while (successor.lchild != None):
        successorParent = successor
	successor = successor.lchild

      # successor node is right child of delete node
      if (deleteNode == self.root):
        self.root = successor
      elif (isLeft):
        parent.lchild = successor
      else:
        parent.rchild = successor

      # connect delete node's left child to be successor's left child
      successor.lchild = deleteNode.lchild

      # successor node left descendant of delete node
      if (successor != deleteNode.rchild):
        successorParent.lchild  = successor.rchild
	successor.rchild = deleteNode.rchild
    return True