Searching and Sorting

• Searching and sorting are two classic problems in computer science.
• We are able to look at them now that we have arrays.
• They are sort of covered in chapter 13, but I want to introduce them now.
• I would like to build a program that reports the number of times each word appears in a file.
• To to this I will need to

  • Main:
        Open the file
        Put the words in an array
        Close the file
    
        Sort the list of words by frequency
        Print the list of words.  

  • I can see using two data structures here
    • A struct to represent a word and the number of times the word appeared in the file.
    • An array of these structs.
• The structure is fairly simple
  • It needs to hold a string, the word.
  • It needs to hold an int, the count.

  • struct WordEntryT {
        string word;
        int count;
    }; 

• The array then becomes

  • const size_t MAX_WORDS = 100;
    WordEntryT words[MAX_WORDS];
    size_t wordCount = 0;

  • Since I don't know how many words I will be dealing with, I will need the wordCount variable as well.
    • This represents two things.
    • The number of words I have stored in the array.
    • The location of the next available space in the array to store a word.
    • 
• Filling the array

  • Put words in an array:
    read a word
    while not end of file 
       if the word is in the array
          increase the count for that word
       else
          if there is space in the array
             add the word to the array
             set the count to be 1
             increase the word count by 1
          else
             print an error message that the array is out of space.
       read in the next word 

  • I implemented this as FillArray.
  • To implement this I need a find function.
• What does a find function do?
  • Given a array of elements and an item to find
  • It returns the location of the item in the array if the item is in the array.
  • It returns a NOT_FOUND value if the item is not in the array.
  • The most simple approach is a straight forward approach.

  • position = NO_POSITION
    for each word in the array
       if the word is equal to the key
          position =  position of the word
    return  position 

• Sorting
  • The task is to put elements of the array in order.
  • There are many ways to do this.
  • We will look at a technique called selection sort
  • This idea is to
    • find the smallest item in the array and move it to the first position.
    • find the second smallest item in the array and move it to the second position.
    • Repeat until done.
  • This maintains an array where on pass $n$
    • The first $n-1$ items are ordered
    • Items $n$ to the end of the array are not in order.
    • 

    • 
       for i = 0 to size
         smallPos = i
         for j = i+1 to size
            if ary[smallPos] > ary[j]
               smallPos = j
         if (smallPos != i)
            Swap(ary[i], ary[smallPos]) 
      

    • Note, this algorithm is much closer to code.
      • this is reasonable.
      • Line 2 records the starting element for a given search as the smallet.
      • Line 5 will record a new smaller element.
      • Line 7 will move the smallest item to the correct spot in the array.
• See wordList.cpp