Lecture Notes on 02 Nov 2022

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

  def __str__ (self):
    s = ''
    return s

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

  # insert data into the tree
  def insert_node (self, data):
    new_node = Node (data)

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

      if (data < parent.data):
        parent.lchild = new_node
      else:
        parent.rchild = new_node

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

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

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

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

  # Find the node with the smallest value
  def min_node (self):
    current = self.root
    parent = self.root
    while (current != None):
      parent = current
      current = current.lchild
    return parent

  # Find the node with the largest value
  def max_node (self):
    current = self.root
    parent = current
    while (current != None):
      parent = current
      current = current.rchild
    return parent

  # delete a node with a given key
  def delete_node (self, data):
    delete_node = self.root
    parent = self.root
    is_left = False

    # if empty tree
    if (delete_node == None):
      return None

    # find the node containing the data
    while (delete_node != None) and (delete_node.data != data):
      parent = delete_node
      if (data < delete_node.data):
        delete_node = delete_node.lchild
        is_left = True
      else:
        delete_node = delete_node.rchild
        is_left = False

    # if node not found
    if (delete_node == None):
      return None

    # check if the delete node is a leaf node
    if (delete_node.lchild == None) and (delete_node.rchild == None):
      if (delete_node == self.root):
        self.root = None
      elif (is_left):
        parent.lchild = None
      else:
        parent.rchild = None

    # check if the delete node is a node with only a left child
    elif (delete_node.rchild == None):
      if (delete_node == self.root):
        self.root = delete_node.lchild
      elif (is_left):
        parent.lchild = delete_node.lchild
      else:
        parent.rchild = delete_node.lchild

    # Delete node is a node with only right child
    elif (delete_node.lchild == None):
      if (delete_node == self.root):
        self.root = delete_node.rchild
      elif (is_left):
        parent.lchild = delete_node.rchild
      else:
        parent.rchild = delete_node.rchild

    # Delete node is a node with both left and right child
    else:
      # Find delete node's successor and successor's parent nodes
      successor = delete_node.rchild
      successor_parent = delete_node

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

      # Successor node right child of delete node
      if (delete_node == self.root):
        self.root = successor
      elif (is_left):
        parent.lchild = successor
      else:
        parent.rchild = successor

      # Connect delete node's left child to be successor's left child
      successor.lchild = delete_node.lchild

      # Successor node left descendant of delete node
      if (successor != delete_node.rchild):
        successor_parent.lchild = successor.rchild
        successor.rchild = delete_node.rchild

    return delete_node