CSCI 1110 - C++ Lecture Notes
Chapter 12 - Applied Arrays

Lists

Sorting

The Binary Search Algorithm

Character Strings

Lists

• A List is a variable-length, linear collection of homogeneous components.
  
  
• An array is often used to represent a list.
  
  
• Data is often organized into lists using parallel arrays.




int id[] = {123, 125, 235, 124, 987};
int exam[] = {92, 78, 86, 34, 98};

Which represents the exam scores of the students with the corresponding ids: 



index	id[]	exam[]
0	123	92
1	125	78
2	235	86
3	124	34
4	987	98

• A  common list operation is a search of the list for a given value. A general-purpose search function needs five parameters:
  
  
1. list    - the array to be searched
2. item    - the item value to be found
3. length  - the length of the list
4. index   - the location of the item if found
5. found   - true if item is found

          false if the item is not found


• Search function:
  
  
#include <bool.h>
typedef int ItemType;
. . .

void Search(
    const ItemType list[],
          ItemType item,
          int      length,
          int&     index,
          bool&    found )
{
    for (index = 0;
         index < length &&
           list[index] != item;
         index++);

   found = index < length);
}
 

The following program fragment could be used to print the exam score for a given student:
 
int main()
{
  int id[] = {123, 125, 235, 124, 987};
  int exam[] = {92, 78, 86, 34, 98};
  int student, location;
  bool found;

  cout << "Enter id: ";
  cin >> student;
  Search(id, student, 5, location, found);
  if (found)
    cout << "Grade for student"
         << student << " is "
         << exam[location] << endl;
  else
    cout << "Student " << student
         << " was not found." << endl;
}
 



• The following version of the Search function is slightly more efficient. It places the item being searched for at the end of the list so it is guaranteed to be found by the loop:

 
void Search(
    const ItemType list[],
          ItemType item,
          int      length,
          int&     index,
          bool&    found )
{
    for (index = 0,
           list[length] = item;
         list[index] != item;
         index++);

   found = index < length;
}



Why is it faster?

Are there any additional requirements for list in order for the function to work properly?
 

Sorting

• Unordered lists work reasonably well for a few items, but sorted lists are much more efficient for larger numbers of items. Imagine for example, if the phone book was in random order.
  
  
• Sorting is the arranging of the components of a list in some order. For example, words into alphabetical order or numbers into ascending or descending order.
  
  
• There are many different sorting algorithms. One of the simplest is known as the Selection Sort. The Selection Sort (for ascending order) can be describes as follows:
  
  

1. Examine the items of the list and locate the smallest item.
   
   
2. Swap the smallest item with the first item in the list.
   
   
3. Repeat steps 1 and 2 starting with the second item in the list. Continue until all items are in their proper place.
   
   
Selection Sort Example. 


• Selection Sort function:
  
  
void SelSort(ItemType list[],
             int      length )
{
  ItemType temp; // used for swapping
  int pass;
  int place;
  int minIndex;

  for (pass = 0;
       pass < length - 1;
       pass++)
  {
    minIndex = pass;

    // find next smallest item
    for (place = pass + 1;
         place < length;
         place++)
    {
      if (list[place] < list[minIndex])
        minIndex = place;
    }

    //swap items
    temp = list[minIndex];
    list[minIndex] = list[pass];
    list[pass] = temp;
  }
}
 



• Insertion in an ordered list:
  
  
void Insert(ItemType list[],
            int&     length,
            ItemType item )
{
  bool found;
  int  index;
  int count;

  SearchOrd(list, item, length,
                  index, found);

  // move items down
  for (count = length - 1;
       count >= index;
       count--)
    list[count + 1] = list[count];

  // insert item
    list[index] = item;

  // increment length of list
    length++;
}
 

The Binary Search Algorithm

• The Binary Search Algorithm is a faster method for finding an item in an ordered list.
  
  
• The Binary Search Algorithm can be described as:
  
  
1. Examine the middle item in the list.
   
   
2. If the middle item is the item being searched for, exit the process.
   
   
3. If the middle item is greater than the item, search the lower half of the table.
   
   
4. If the middle item is less than the item, search the upper half of the table.
   
   
5. Continue the process until either the item is found or no more items are left in the table.
   
   
• The Binary Search Algorithm:
  
  
void BinSearch(
          const ItemType list[],
                ItemType item,
                int      length,
                int&     index,
                bool     found )
{
  int first = 0;
  int last = length - 1;
  int middle;

  found = false;
  while (!found && last >= first)
  {
    middle = (first + last) / 2;
    if (item < list[middle])
      last = middle - 1;
    else if (item > list[middle])
      first = middle + 1;
    else
      found = true;
   }
   index = middle;
}
 



• Since each iteration of the Binary Search loop eliminates half of the remaining items in the list, doubling the number of items only increases the search time by one.
  
  
• The amount of work associated with the Binary Search Algorithm is proportional to Log₂ N, where N is the length of the list being searched.
  
  

N	Log2 N
2	1
4	2
8	3
16	4
32	5
1,024	10
32,768	15
1,048,576	20
33,554,432	25
1,073,741,824	30

 

Character Strings

• A Character String is a collection of characters interpreted as a single item.
  
  
• In C++, a character string is a null-terminated sequence of characters stored in a char array.
• The null character has all bits off and is written as '\0'.
  
  
• To initialize a string, follow the char array declaration with the equal character and a string of characters enclosed in double quotes:
  
  

    char promptMsg[] = "Enter a positive number: ";
    char errMsg[] = "Value must be positive.";

promptMsg is stored in 26 locations, one for each character plus one for the null character.



• Unlike arrays of other data types, input and output of char arrays using >> and << are aggregate operations:
  
  

   char promptMsg[] = "Enter a name: ";
   char name[30];

   cout << promptMsg;
   cin >> name;



• cin.get can also be used to input character strings:

   char oneLine[81];

   cin.get(oneLine, 81);

reads up to 81 characters or until the end of the line ('\n' character).



• This form of the cin.get function reads up to the '\n' character but it does not consume it.

   char oneLine[81];
   char dummy;

   cin.get(oneLine, 81);
   cin.get(dummy);  // consume the end of line



• The cin.ignore function is used to skip characters until a specified character is found. cin.ignore does consume the character it is looking for.

   char response[5];

   cin.get(response, 5);
   cin.ignore(100, '\n');

This will skip up to 100 characters or until the end of line character is encountered.



• Using character arrays, you can ask the user to supply the names of input or output files at run time:

   ifstream inFile;
   char fileName[51];

   cout << "Enter file name: ");
   cin.get(fileName, 51);
   cin.ignore(100, '\n');

   inFile.open(fileName);
   if(!inFile)
   {
     cout << "Unable to open file "
          << fileName << endl;
     return 1;
 }



• string.h contains a number of character string oriented functions:
  
  

Function	Function value	Effect
strlen(str)	Integer length of str (excluding '\0')	Computes the length of str
strcmp(str1, str2)	<0 if str1 < str2 0 if str1 == str2 >1 if str1 > str2	Compares str1 with str2
strcpy(toStr, fromStr)	Base address of toStr (usually ignored)	Copies fromStr characters to toStr
strcat(toStr, fromStr)	Base address of toStr (usually ignored)	Concatenated (appends) fromStr characters to the end of toStr