Introduction

• He bases some of his discussion in this chapter on the idea of a dictionary
  • This is from chapter 8
  • ADT:
    • Domain
      • A collection of objects accessed through a key
      • This may be ordered or unordered
      • ** This may be easy, or difficult to find based on the key
    • Properties
      • Size
      • isEmpty
      • elements, keys
      • Find(key)
      • findAll(key)
      • insertItem(key,element)
      • removeElement(key)
      • removeAllElements(k)
  • A simple list may suffice for implementation, but we can do better
  • If we have time, we will be back to look at this
  • If not, you will learn all about it in compilers. (Save this book)
• What is important is that we want to be able to
  • Insert elements quickly
  • Delete elements quickly
  • Find elements quickly
  • Will a heap do?

Binary Search Trees

• We briefly looked at BST's in chapter 6
• Properties
  • Each node stores an element
  • all nodes in the left subtree are "less than or equal to" the root of the subtree
  • All nodes in the right subtree are "less than or equal to" the root of the subtree
• He continues with null nodes as leaves, thus all data is stored in an internal node
  • This just makes it so we can check to see if a node is valid by isInternal or isExternal
  • I didn't do this in my examples
  • In any case, he returns a null if you proceed to a leaf node.
  • And in his implementation he adds a function isNull
• Searching

  • TreeSearch(k,v,T)
    (0)   if v is external
    (1)       return NULL
    (2)   if k = key(v)
    (3)       return v
    (4)   if k < key(v)
    (5)       return TreeSearch(k,T.leftChild(v),T)
    (6)   else
    (7)       return TreeSearch(k,T.rightChild(v),T)
         

  • Is it correct?
    • Given that T follows the binary search tree properties
    • If the key is at the root, it will be returned at line 2
    • If the key is less than that at the root, it is either in the left sub tree, or not in the tree at all (lines 4-5)
    • Otherwise the key is in the right sub tree or not at all (lines 6-7)
  • Timing:
    • Similar to other arguements, if the value we are searching for is not in the tree, we must traverse a path from the root to a node. In the worst case, we will traverse from the root to the node with the gratest depth, or the height of the tree. This algorithm, then is O(h), but there is no bound on h, so it is O(n) worst case.
• Insertion:
  • Insertion is much like finding an element, except that we allways need to traverse the entire depth of a path. (IE we only insert at the leaves)

  • Insert(v,k,e,T)
    (0)   if k < T.element(v)
    (1)      if T.isNull(T.leftChild(v))
    (2)         T.AddLeftChld(v,k,e)
    (3)      else
    (4)         Insert(T.leftChild(v),k,e,T)
    (5)   else if T.isNull(T.rightChild(v))
    (6)      T.AddRightChild(v,k,e)
    (7)   else
    (8)      Insert(T.rightChild(v),k,e,T)
    	

  • This assumes we write a special code to make sure that the root is not empty.

    (0) If T.isNull(T.root())  
    (1)     T.AddRoot(k,e)
    (2) else 
    (3)     Insert(T.root(),k,e,T)
    	     

  • Is it correct?
  • What is the timing?
• Deleting A Node
  • Two routines are used here
  • The first will delete a node with 0 or one child
  • The second will find the next largest element in the sub tree and remove it from the tree
  • This is usseful when we are deleteing a node with two children.

  • itemType DeleteMin(v, T) 
    (0)  if isNull(T.leftChld(v)) 
    (1)     tmp = T.element(v)
    (2)     replace v with right child of v
    (3)     return tmp
    (4)  else
    (5)    return DeleteMin(T.leftchild(v),T)
           

  • Here we have a sub tree, and we look for the leftmost node
  • This will be the minimum value of the subtree
  • It will have no left child, so we can easily delete it from the tree

  •  
    Delete(v, k, T) 
    (0)   if !T.isNull(v) 
    (1)      if k < T.element(v)
    (2)         Delete(T.leftChild(v),k,T)
    (3)      else if k > T.element(v)
    (4)         Delete(T.rightChild(v),k, T)
    (5)      else if T.isNull(T.leftChild(v)) and T.isNull(T.rightChild(v))
    (6)         remove node v
    (7)      else if T.isNull(T.leftChild(v)
    (8)         replace v with the right child of v
    (9)      else if T.isNull(T.rightChild(v)
    (10)        replace v with the left child of v
    (11)     else
    (12)        T.replaceElement(v,DeleteMin(T.rightChild(v),T))
    

  • If it is not the node, look to the left or right
  • If it is the node, but has less than two children promote the child to the node's position
  • Otherwise remove the minimum node in the right subtree and move it up to this node's position
  • Correctness:
    • We should argue that replacing the node with the minimum in the right subtree is correct.
    • We should argue that promoting the single child is correct
    • We should argue that we will find the proper node.
  • Timing
    • We should argue that the worst case is the height of the tree.
• Performance notes:
  • Clearly these algorithms behave better if we have a fuller tree
  • Again, clearly the case of sorted input is worst.
  • We can argue that a random input will give us a good tree. (but notice there is no clearly here)
• Please see my example code.