public boolean isPath(City originCity, 
               City destinationCity) {
// ---------------------------------------------------
// Determines whether a sequence of flights between two cities
// exists. Nonrecursive stack version.
// Precondition: originCity and destinationCity are the origin
// and destination cities, respectively.
// Postcondition: Returns true if a sequence of flights exists
// from originCity to destinationCity, otherwise returns 
// false. Cities visited during the search are marked as 
// visited in the flight map.
// Implementation notes: Uses a stack for the cities of a 
// potential path. Calls unvisitAll, markVisited, and 
// getNextCity.
// ---------------------------------------------------
  StackReferenceBased stack = new StackReferenceBased();
                      
  City topCity, nextCity;
  unvisitAll();  // clear marks on all cities

  // push origin city onto stack, mark it visited
  stack.push(originCity);
  markVisited(originCity);

  topCity = (City)(stack.peek());
  while (!stack.isEmpty() &&
         (topCity.compareTo(destinationCity) != 0)) {
    // loop invariant: stack contains a directed path 
    // from the origin city at the bottom of the stack  
    // to the city at the top of the stack

    // find an unvisited city adjacent to the city on 
    // the top of the stack
    nextCity = getNextCity(topCity);

    if (nextCity == null) {
      stack.pop();  // no city found; backtrack
    }
    else {                  // visit city
      stack.push(nextCity);
      markVisited(nextCity);
    }  // end if
    topCity = (City)stack.peek();
  }  // end while
  if (stack.isEmpty()) {
    return false;  // no path exists
  }
  else {
    return true;   // path exists
  }  // end if
}  // end isPath