Lecture Notes on 22 Jul 2020

* Slides on Tress

https://www.cs.utexas.edu/users/mitra/csSummer2020/cs313/notes/Trees.pdf

* Pictorial Representation of Trees

https://www.cs.utexas.edu/users/mitra/csSummer2020/cs313/notes/Binary_Trees.pdf

* Operations and Algorithms on Binary Search Trees

* Define a Node:
  - data
  - lchild
  - rchild

* Create an Empty Tree
  - root = None

* Insert elements in the Tree
  - create Node
  - find unique location in Tree and add
  - new addition always a leaf node

* Find a node containing some data value in Tree
  - always start at the root
  - go left if data value is less than node value
  - go right if data value is greater than node value

* Find minimum value in a Tree
  - go left until you hit a node that does not have a left child

* Find maximum value in a Tree
  - go right until you hit a node that does not have a right child

* Traverse a Tree
  - traverse a Tree means to visit every node just once
  - the following algorithms looks upon the Tree as a recursive
    data structure

* Inorder Traversal
  - start at the root
  - recursively go to the left subtree
  - visit root and print
  - recursively go to the right subtree

* Preorder Traversal
  - visit root and print
  - recursively go to the left subtree
  - recursively go to the right subtree

* Postorder Traversal
  - recursively go to the left subtree
  - recursively go to the right subtree
  - visit root and print

* Expression Tree

Code for Binary Search Tree

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

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

  # insert data into the tree
  def insert (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

      # found location now insert node
      if (data < parent.data):
        parent.lchild = new_node
      else:
        parent.rchild = new_node

  # search for a node with given data
  def find (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

  # find the node with the minimum key
  def find_min (self):
    current = self.root
    parent = self.root
    while (current != None):
      parent = current
      current = current.lchild
    return parent

  # find the node with the maximum key
  def find_max (self):
    current = self.root
    parent = self.root
    while (current != None):
      parent = current
      current = current.rchild
    return parent

  # in order 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)

  # pre order 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)

  # post order 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)