Complete the Flight practice problem before reviewing the solution.

Review the Flight solution with AP CS Tutor Brandon Horn.

## Part (a)

```
public List<String> frequentFlyers()
{
List<String> frequentFlyers = new ArrayList<String>();
for (int row = 0; row < rows; row++)
for (int seat = 0; seat < seatsPerRow; seat++)
if (seats[row][seat] != null && seats[row][seat].isFrequentFlyer())
frequentFlyers.add(seats[row][seat].passengerName());
return frequentFlyers;
}
```

This method requires only a simple traversal of the entire 2D array. Traversal of a 2D array is most easily accomplished using a nested for loop, which allows both access to and modification of each element. In this case, each reservation is checked for frequent flyer status and the names of frequent flyers are added to the list to be returned.

The instance fields rows and seatsPerRow could be replaced with seats.length and seats[0].length, respectively. On the AP Computer Science Exam, instance fields are often used in place of array.length and array[0].length to emphasize that the 2D array is rectangular (does not contain rows with different lengths).

## Part (b)

```
public boolean reserveAdjacentSeats(String passOneName, String passTwoName)
{
for (int row = 0; row < rows; row++)
{
for (int seat = 1; seat < seatsPerRow; seat++)
{
if (seats[row][seat - 1] == null && seats[row][seat] == null)
{
seats[row][seat - 1] = new Reservation(passOneName);
seats[row][seat] = new Reservation(passTwoName);
return true;
}
}
}
return false;
}
```

All rows must be traversed as usual; however, each row must be traversed carefully to avoid exceeding the array bounds. Checking for adjacent empty seats requires checking 2 array positions for each run of the inner loop. If the loop traversed the entire row as usual, it would exceed the bounds at either the first or the last element. If possible, I prefer to start my loops at an unusual value rather than end them at an unusual value. In this method, my inner loop starts at 1 rather than 0 and checks each seat and the seat prior to it.

## Part (c)

```
public boolean reserveWindowSeat(String passengerName)
{
for (int row = 0; row < rows; row++)
{
if (seats[row][0] == null)
{
seats[row][0] = new Reservation(passengerName);
return true;
}
if (seats[rows][seatsPerRow - 1] == null)
{
seats[row][seatsPerRow - 1] = new Reservation(passengerName);
return true;
}
}
return false;
}
```

Window seats are defined as those in columns 0 or seatsPerRow – 1. Those seats must be checked in each row. There is no nested loop because only 2 specific seats must be checked in each row.

## Part (d)

```
public List<String> isolatedPassengers()
{
List<String> isolatedPassengers = new ArrayList<String>();
for (int row = 0; row < rows; row++)
{
if (seats[row][0] != null && seats[row][1] == null)
isolatedPassengers.add(seats[row][0].passengerName());
for (int seat = 1; seat <= seatsPerRow - 2; seat++)
if (seats[row][seat] != null && seats[row][seat - 1] == null && seats[row][seat + 1] == null)
isolatedPassengers.add(seats[row][seat].passengerName());
if (seats[row][seatsPerRow - 1] != null && seats[row][seatsPerRow - 2] == null)
isolatedPassengers.add(seats[row][seatsPerRow - 1].passengerName());
}
return isolatedPassengers;
}
```

The outer loop traverses all rows as usual. The first and last seats in each row have only 1 adjacent seat each, so they must be checked separately. Each middle seat has 2 adjacent seats (one on each side). The bounds for the loop that traverses the middle seats must exclude both the first and last seat to prevent a bounds error. Three seats must be checked for each iteration of the inner loop (the seat at position seat, and each of the 2 adjacent seats).