Algorithms

mynode *closestAncestor(mynode* root, mynode* p, mynode* q)
{
   mynode *l, *r, *tmp;

   if(root == NULL)
   {
      return(NULL);
   }

 if(root->left==p || root->right==p || root->left==q || root->right==q)

   {
     return(root);
   }
   else
   {
      l = closestAncestor(root->left, p, q);
      r = closestAncestor(root->right, p, q);

      if(l!=NULL && r!=NULL)
      {
        return(root);
      }
      else
      {
         tmp = (l!=NULL) ? l : r;
         return(tmp);
      }
   }
}

int closestanc(node * root, int n1, int n2)
{
    int l, r;
    if(root == NULL)
    return -1;
    if(root->right->data == n1 || root->right->data == n2 || root->left->data == n1 || root->left->data == n2)
    return root->data;
    else
    {
        l = closestanc(root->left, n1, n2);
        r = closestanc(root->right, n1, n2);
        if(l!= -1 && r!= -1)
        return root->data;
        else
        return (l != -1 ? l : r);
    }
}

• HTML/XML validation and correction
  
• C++ source code analysis
  
• Analysis of email chains
  
• Automatic chaining of tools in a workflow
  
• Transformation from syntax to semantics in natural language processing
  
• Computer algebra

1. allows wild cards not only in the tail part of a pattern, but anywhere in a pattern,
2. in the case of matching against a list, is capable of matching any number of consecutive elements anywhere in the list, and not just the 'head' of the list,
3. is visually clean, attractive and readable,
4. allows 'normal' instructions to be embedded in patterns (evaluation of variables, writing to files, function calls, other pattern match operations, etc.),
5. can assign a matched part of the subject to a variable,
6. can match part of a subject with the content of a variable,
7. uses the same pattern syntax for string pattern matching by treating a string as a special case of a list.