Lecture Notes
for Data Structures + Algorithms: CS 3100

bool isAnIdentifier (string s) 
{
        if (length(s) < 1) return false ;  // base case
   else if (length(s) == 1)               // another base case
        { if (s is a letter) return true; else return false; }
   else if (the last character of s is a NOT letter or a digit) 
        return false ;
   else return isAnIdentifier(s minus its last character) ; // the recursive call        
}

#include <iostream>
#include <string>

using namespace std;

bool isAnIdentifier (string str) ;
bool isLetter (char c) ;
bool isDigit (char p) ;

int main ()
{
  string testStr;

  cout << endl << endl << "The Identifier Checker is running." ;
  cout << endl << endl ;

  while (cin >> testStr)
  {
    cout << testStr << endl;
    if   (isAnIdentifier(testStr))
         cout << "The string IS an identifier." << endl ;
    else cout << "The string IS NOT an identifier." << endl ;
  }
  cout << endl << endl << "The Identifier Checker Thanks You!" ;
  cout << endl << endl ;

  return 0 ;
}

/*
The grammar:
<identifier> = <letter> | <identifier><letter> | <identifier><digit>
<letter> = a | b | ... | z | A | B | ... | Z | _
<digit> = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 

*/

bool isAnIdentifier (string str)
{
   int len = str.length() ;

        if (len < 1) return false ;
   else if (len == 1) 
        {
           if   ( isLetter (str[0]) )
                return true ;
           else return false ;
        }
    else if ( !isLetter(str[len-1]) && !isDigit(str[len-1])  )
         return false ;
    else return isAnIdentifier (str.substr(0,len-1)) ;
}

bool isLetter (char c) 
{
   if ( 
             ( ('a' <= c) && (c <= 'z') ) 
         ||  ( ('A' <= c) && (c <= 'Z') )
         ||  (  c == '_') 
      )
   return true ;
   else return false;
}

bool isDigit (char p) 
{
   if (  ('0' <= p) && (p <= '9')  )
   return true ;
   else return false;
}

A grammar for PALINDROMES

<pal> = empty string | <ch> | a<pal>a | b<pal>b | ... | Z<pal>Z
<ch> = a | b | ... | z | A | B | ... | Z 

The text discusses on page 163 how to construct a recognition algorithm 
based on this grammar.

A grammar for PREFIX expressions
<prefix> = <identifier> | <operator><prefix><prefix> 
<operator> = + | - | * | / 
<identifier> = a | b | c | ... | z 

<operator><prefix><prefix>

+-+xy/cd*ab

+-+xy/cd*ab

-+xy/cd

The algorithm inputs a string and an integer representing a first position.
If the string contains a prefix expression that starts at the first position, 
the algorithm returns the position of the end of that prefix expression.  
Otherwise the algorithm returns -1 as a failure code.
algorithm name: endPre 
inputs: string strExp, and integer first
outputs: integer 
{
    if first < 0, return (-1) ;  // no place to start the expression
    let integer last = the index of the last character in strExp 
    if first > last, return (-1) // no characters for the expression 
    let ch = the character at position first of strExp
    if (ch is an identifier) return (first) // base case
    else if (ch is NOT an operator) return (-1) // there's no expression
    else 
    {
        /* recursively find the end of the first prefix 
           expression after the operator ch, if it's there. */
        let firstEnd = endPre (strExp, first+1) 
        if   (firstEnd == -1) // If there was no expression
             return (-1)
           /* Otherwise return the position of the end of the 
              second expression after ch, if it exists, 
              or the failure code (-1) if it does not exist. */
        else return endPre(strExp, firstEnd+1) 
    }
}

Once we have the algorithm above, we can write a very 
simple algorithm to input a string and return true or false, 
depending on whether the string is a prefix expression. 
algorithm name: isPrefix
inputs: string strExp
outputs: boolean
{
    let lastChar = endPre(strExp, 0)
    if   ( (lastChar >= 0) && (lastChar == strExp.length()-1) )
         return (true)
    else return (false)
}

int findIndexofLargest (const ItemType theArray[ ], int numElts)
{
  int indexSoFar = 0;   // Index of largest entry found so far
  for (int indexNow = 1; indexNow < numElts; indexNow++)
    {
       if (theArray[indexNow] > theArray[indexSoFar])
          indexSoFar = indexNow;
    }
  return indexSoFar;    // Index of largest entry
}

void selectionSort (ItemType theArray[ ], int listSize)
{
      /* lastPstn is the index of the last item in the 
         sub-array of items that are not sorted yet. */
   int lastPstn, maxLoc ;
   for (lastPstn = listSize-1; lastPstn >= 1; lastPstn--)
   {
      maxLoc = findIndexofLargest (theArray, lastPstn + 1);
      std::swap (theArray[maxLoc], theArray[lastPstn]);
   }	
}

O(listSize²)

• Pick an element of the list to use as a pivot,
• Doing O(N) work, partition the list into a first segment containing only elements less than or equal to the pivot, a second segment containing the pivot, and a third segment containing only elements greater than or equal to the pivot, and
• Sort the first first and third segments (using quicksort).