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)
      
            if T.isRoot(v)
              return 0
           else
              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) 
      
         h = 0
         for each v in T.positions() do
            if T.isExternal(v) then
                h = max(h, depth(T,v))
          return(h)
      
      	  

    • Performance of this algorithm.
      • line 2 is O(n)
      • Line 3 is O(|E|), where E is the set of external nodes
      • Line 4 is d_v, the depth of the given leaf.
      • But this is another sum example, not a product.
        • If all leaf nodes are children of the root,
        • d_v = 1, so the algorithm is
        • line (3) n-1
        • line (4) 1
        • which is n+n-1 + 1 = 2n
        • The hight of the tree, and the number of leaves are inversely 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 (3) n/2 times
        • And line (4) 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)
      
         if T.isExternal(v) then
            return(0)
         else
            h = 0
            foreach w in T.children(v) do
               h = max(h, height2(T,w))
            return(h+1)
      
      	
               

    • Essentially, 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)
• Traversals
  • A traversal is a systematic way of "visiting" each node in a tree
  • Three kinds
    • preorder - visit the node, preorder visit children in order
    • 
    • (A, B, E, F, C, D, G, H, I)
    • inorder - inorder visit the first child, visit the node, inorder visit the other children in order
    • 
    • (E, B, F, A, C, G, D, H, I)
    • postorder - postorder visit the children, visit the node
    • 
    • (E, F, B, C, G, H, I, D, A)
  • Preorder Traversial

    PrintPreorder(v)
    
      print v.element() 
      foreach w in children(v)
          PrintPreorder(w)
    
           

  • Inorder Traversal

    PrintInorder(v)
    
      PrintInorder(firstchild(v))
      print v.element 
      foreach w in children(v)-firstchild(v)
          PrintInorder(w)
    
    

  • Postorder Traversal

    PrintPostorder(v)
    
      foreach w in children(v)
          PrintPostorder(w)
      print v.element 
    
           

  • Each of these is O(n), where n is the number of nodes in the tree.
  • We could also do a breadth first visit using a queue
  • Or other types of traversals.