Basic Algorithms

• Running Time Assumptions
  • We assume the following are O(1)
    • Root(), Parent()
    • isInternal(), isExternal(), isRoot()
    • swapElements(), replaceElement()
  • These take O(n), n is the number of elements in the tree
    • elements(), positions()
• Depth and Height
  • Depth
    • The depth of a node v in a tree T is the number of proper ancestors of v.
      • The root has depth 0
      • All other nodes have depth of 1 + depth of parent
      • ie, count the number of links from the root to a node.
    • The following algorithm computes the depth of a node.

      Depth(tree T,  node v)
      (1)     if T.isRoot(v)
      (2)       return 0
      (3)    else
      (4)       return(1 + depth(T,v.parent()));
             

    • 
    • 
    • This algorithm is O(depth(v)+1)
      • Best case O(1), for the root
      • Worst case O(n), n = number of nodes, for a linear tree (linked list)
      • In general, for trees, we like them when they "branch"
      • Because this reduces running time of many algorithms.
  • Height
    • The height of a node is
      • 0 if the node is a leaf
      • one plus the maximum height of the children of the node.
    • 
    • Theorem: The height of a tree T is equal to the maximum depth of an external node.
    • Algorithm for finding the height of a tree:

      Height(T) 
      (1)  for each v in T.positions() do
      (2)    if T.isExternal(v) then
      (3)       h = max(h, depth(T,v))
      (4)  return(h)
      	  

    • Performance of this algorithm.
      • line 1 is O(n)
      • Line 2 is O(|E|), where E is the set of external nodes
      • Line 3 is d_v, the depth of the given leaf.
      • But this is another sum example, not a product.
      • Goodrich argues
        • |E| <= n-1
        • d_v <= h <= n-1
        • Therefore, (2) and (3) are |E|*h < (n-1)*(n-1)
        • Thus the algorithm is O(n +n²)
        • This case occurs when all leaves are children of the root
      • But:
        • If all leaf nodes are children of the root,
        • d_v = 1, so the algorithm is
        • line (2) n-1
        • line (3) 1
        • which is n+n-1 + 1 = 2n
        • The hight of the tree, and the number of leaves are inversly related.
          • The more leaf nodes, the lower the height
          • The greater the height, the fewer leaf nodes.
        • Picture a tree of height n/2, with n/2 leaves
        • 
        • We then execute line (2) n/2 times
        • And line (3) has d_v = n/2
        • So the algorithm is n+n/2*n/2 = n+1/4n²
        • or O(n²)
  • A better algorithm:

    height2(T,v)
    (1)  if T.isExternal(v) then
    (2)     return(0)
    (3)  else
    (4)     h = 0
    (5)     foreach w in T.children(v) do
    (6)        h = max(h, height2(T,w))
    (7)     return(h+1)
    	
             

  • Essentually, recurse down the tree computing the height
  • Timing:
    • For each node n in the tree, height2(n) will be called once
    • At a leaf node, the time is constant.
    • At an internal node, the time is c_v
    • where c_v is the number of children the node has.
    • So it is really O(n+ sum c_v)
    • Proposition:
    • 
    • Probably prove by induction on the number of nodes in the tree.
    • So the algorithm is O(n)