Module 1: Conditionals

Now we'll look at a few examples of working with arrays and conditionals in nested loops.

First, let's examine an array to see if it has duplicates:

1.30 Exercise: In module1.pdf, trace through the above program, drawing a picture of the array and tracking i and j.

1.31 Video:

Note:

• First, notice the starting value for j:

  

• Next, notice that the two loop entry conditions are different:

  

• This is a "standard" form of nested-loop that allows all possible pairs of elements to be compared.

Next, we'll write a program to simply count occurences of each integer in an array:

1.32 Exercise: In module1.pdf, trace through the above program, drawing a picture of the occurenceCount array and tracking its values. Do you see why we need max+1 as the size for the occurenceCount array?

• Notice how we used an array value as an index:

  

• The output above resulted in printing the occurence count multiple times for some integers.

• Here's one way to address the problem:

  
      public static void main (String[] argv)
      {
          int[] A = {2, 9, 2, 6, 4, 3, 3, 2};
          int max = 9;
          int[] occurenceCount = new int [max+1];
          for (int i=0; i<A.length; i++) {
              occurenceCount[A[i]] ++;
          }
          for (int k=0; k<occurenceCount.length; k++) {
              if (occurenceCount[k] > 0) {
                  System.out.println (k + " occurs " + occurenceCount[k] + " times");
              }
          }
      }
       

1.33 Exercise: Execute the above program (in MyOccurenceCount.java) to see how it works. Then, (in module1.pdf) trace through the second for-loop above.

Note:

• We're only printing a count for those elements that occur at least once.

• We've used a different for-loop variable in the second loop. This is strictly not necessary. We could have had

          for (int i=0; i<occurenceCount.length; i++) {
              if (occurenceCount[i] > 0) {
                  System.out.println (i + " occurs " + occurenceCount[i] + " times");
              }
          }
       

  But it's good style to use a different variable name to alert the reader that the meaning of the variable is different.

• We've replaced the multiple print's with a single println that combines strings and numbers (into a larger string).

• In the above programs, we manually look at the array A and wrote down the maximum value (9) in the code ourselves

          int max = 9;
       

• This is an example of what's called hard coding:
  • The term is used as the verb, to hard code.
  • It refers to actual data in the code that's fixed ahead of time.
  • It's generally NOT a good idea.
  • Here, we're doing this for simplicity of explanation.
  • In a real application, we would not know the contents of of the array ahead of time.

• It's easy to fix this by writing code to find the maximum.

1.34 Exercise: In MyOccurenceCount2.java, replace the hard-coded max with code that finds the maximum of the array A.

Searching the elements of one array in another:

• This is a very common operation in processing data:
  • We have existing data.
  • New data comes in, and we want to see which of the new data already exists.

• In our example, suppose we have

  	int[] recentData = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
  	int[] existingData = {2, 3, 5, 7, 11, 13, 17, 19};
       

• As output, we want to print 3, 5, 7, 11, 13, 17, 19.

• Thinking at a high (pseudocode) level, we want something like:

       for i=0 ... (the first array) {
           // Look for this i-th element in the second array
           for j=0 ... (try each element of the second) {
               if i-th of first == j-th of second {
                   // Found!
               }
           }
       }
       

1.35 Exercise: In TwoArraySearch.java, write code to use the above data and solve the problem.

1.36 Video: