1. CSCI 51 Introduction to Programming March 10, 2009

2. Declaration vs. Instantiation public class Dice { private Die[] dice; // declaration public Dice(int numDice) { dice = new Die[numDice]; // instantiation for (int i=0; i<dice.length; i++) { dice[i] = new Die(); } NOT // declaration and instantiation Die[] dice = new Die[numDice]; creates a new local variable called dice

3. Declaration vs. Instantiation public class Dice { private Die[] dice; public Dice(int numDice) { dice = new Die[numDice]; for (int i=0; i<dice.length; i++) { dice[i] = new Die(); } dice this 0 1 2 face 3

4. Declaration vs. Instantiation public class Dice { private Die[] dice; public Dice(int numDice) { Die[] dice = new Die[numDice]; for (int i=0; i<dice.length; i++) { dice[i] = new Die(); } dice this dice 0 1 2 face 3

5. Writing Test Programs Die class –constructor - takes no parameters –getFace - returns the die's face value as int –roll - takes no parameters, returns nothing, rolls the die Tests –create two Die objects –roll both Die objects –print the face value of both Die objects Die die1 = new Die(); Die die2 = new Die(); die1.roll(); die2.roll(); System.out.println ("die1: " + die1.getFace()); System.out.println ("die2: " + die2.getFace());

6. DieTester.java public class DieTester { public static void main (String[] args) { Die die1 = new Die(); Die die2 = new Die(); die1.roll(); die2.roll(); System.out.println ("die1: " + die1.getFace()); System.out.println ("die2: " + die2.getFace()); }

7. Writing Test Programs Dice class –constructor - takes an int parameter (number of dice) –roll - takes no parameters, returns nothing, rolls all of the dice –getNumDie - takes no parameters, returns the number of dice –getDie - takes an int parameter (position), returns the Die at that position –toString - takes no parameters, returns String of all of the dice's face values

8. Writing Test Programs Tests –create a Dice object with 3 dice and another Dice object with 7 dice –roll all of the dice –print the 3-dice Dice object –print the 7-dice Dice object –print the face value of the 3rd die in the 7-dice Dice object Dice dice3 = new Dice(3); Dice dice7 = new Dice(7); dice3.roll(); dice7.roll(); System.out.println ("3 dice: " + dice3); System.out.println ("7 dice: " + dice7); System.out.println ("3rd die: " + dice7.getDie(2).getFace());

9. DiceTester.java public class DiceTester { public static void main (String[] args) { Dice dice3 = new Dice(3); Dice dice7 = new Dice(7); dice3.roll(); dice7.roll(); System.out.println ("3 dice: " + dice3); System.out.println ("7 dice: " + dice7); System.out.println ("3rd die: " + dice7.getDie(2).getFace()); }

10. Finding Pairs 01234 How do you pick which ones are pairs? Remember, a computer can only compare two things at a time.

11. Finding Pairs 01234 ind1ind2 Does Die at ind1 equal Die at ind2? 01-4 12-4 23-4 34 int len = dice.getNumDice(); for (int ind1 = 0; ind1<len-1; ind1++) { // save face value of Die at ind1 for (int ind2 = ind1+1; ind<len; ind2++) { // save face value of Die at ind2 // compare face values -- if match -> print } length of array? 5

12. Equality Die die1 = dice.getDie(ind1); Die die2 = dice.getDie(ind2); if (die1.getFace() == die2.getFace()) if (die1.equals(die2)) public boolean equals (Die otherDie) { if (getFace() == otherDie.getFace()) { return true; } return false; } in Die class

13. New Stuff Searching arrays for a particular value –reference: Ch 11 Sorting arrays –makes searching for a particular value easier (and quicker) –reference: Ch 12

14. Searching Arrays Find one particular element in an array of many elements Find several particular elements in an array of many elements Complexity (How Long To Search?) –find a parking space - linear –look up a word in a dictionary - complex 500K+ words in OED – search - very complex over 3 trillion web pages

15. Linear Searching Given a test value and a list of values –list can be ordered or unordered –loop through the list repeatedly ask: Is this a match? quit when the answer is yes (use break stmt) –if you finish all items, there is no match Inefficient –worst time to search is ~ length –average time to search is ~ length/2 Relatively easy to program

16. // Linear search of unordered list of integers // unordered list int[] list = {17, 14, 9, 23, 18, 11, 62, 47, 33, 88}; // look for this value in the list int searchFor = 33; // Loop thru list until we find match int foundAt = -1; // where found (default) for (int index = 0; index < list.length; index++) { if (list[index] == searchFor) { foundAt = index; break;// jump out of the loop } // foundAt is now index of item “searchFor” // or -1 if not found

17. // Linear search of unordered list of Strings // unordered list String[] list = {“Bart”, “Homer”, “Marge”, “Lisa”, “Maggie”, “Millhouse”}; // look for this value in the list String searchFor = “Maggie”; // Loop thru list until we find match int foundAt = -1; // where found (default) for (int index = 0; index < list.length; index++) { if ( list[index].equals(searchFor) ) { foundAt = index; break;// jump out of the loop } // foundAt is now index of item ``searchFor’’ // or -1 if not found

18. Binary Search Requires ordered (sorted) list Set searchRange to the entire list Repeat: –pick a “test value” in the middle of searchRange –if test value == value searching for Stop! –if test value > value searching for searchRange = lower half of searchRange –if test value < value searching for searchRange = upper half of searchRange

19. Example 2 4 5 12 16 19 22 26 29 32 37 41 46 50 Looking for 46 Trial 1 2 3 2 4 5 12 16 19 2226 29 32 37 41 46 50 2 4 5 12 16 19 22 26 29 32 3741 46 50

20. Notes on Binary Searches List must be ordered (sorted) –can maintain a list in ordered fashion Much more efficient than linear –in example, took 3 iterations instead of 13 –time ~ log 2 (listLength) –linear worst case ~ listLength average ~ listLength/2 –for 100K words: 17 iterations versus 50,000 More complex to program

21. Searching Things To Know Be able to recognize and write a linear search Understand its pros and cons Know the concepts of a Binary Search

22. Questions 2 10 17 45 49 55 68 85 92 98 How many comparisons are needed to determine if the following items are in the list of 10 items? linear searchbinary searchnumber 15 49 98 2 103 5 1 4 1 3 (49, 10, 17) (49, 85, 92, 98) (49, 10, 2) (3, if know list sorted)

23. Sorting Put elements of an array in some order –alphabetize names –order grades lowest to highest Two simple sorting algorithms –selection sort –insertion sort

24. Selection Sort Sorts by putting values directly into their final, sorted position For each position in the list, the selection sort finds the value that belongs in that position and puts it there

25. Selection Sort General Algorithm Scan the list to find the smallest value Exchange (swap) that value with the value in the first position in the list Scan rest of list for the next smallest value Exchange that value with the value in the second position in the list And so on, until you get to the end of the list

26. Selection Sort At Work 9868837493 6898837493 6874839893 6874839398 SORTED!

27. Selection Sort Sorts in ascending order Can be changed to sort in descending order –look for max instead of min

28. Insertion Sort Like we’d actually sort things Insert each new item into an already sorted list Each unsorted element is inserted at the appropriate spot in the sorted subset until the list is ordered

29. Insertion Sort General Algorithm Sort the first two values (swap, if necessary) Repeat: –insert list’s next value into the appropriate position relative to the first ones (which are already sorted) Each time insertion made, number of values in the sorted subset increases by one Other values in array shift to make room for inserted elements

30. Insertion Sort At Work 9868837493 6898837493 6883987493 6874839893 6874839398 SORTED!

31. Insertion Sort Outer loop controls the index in the array of the next value to be inserted Inner loop compares the current insert value with values stored at lower indexes Each iteration of the outer loop adds one more value to the sorted subset of the list, until the entire list is sorted

32. Bubble Sort "bubble" –largest values bubble to the end –smallest values sink to the beginning Idea –go through the list and swap neighboring items if needed Pros –easy to understand and code Cons –horribly inefficient (listLength 2 )

33. Bubble Sort At Work 9868837493 6898837493 6883987493 6883749893 6874839398 SORTED! 6883749398

34. Sort Implementations All three use double (nested) loops Selection and insertion –an outer loops scans all elements –an inner loop scans and switches/inserts as needed Bubble –an outer loop repeats until no swaps are needed –an inner loops scans and swaps as needed

35. Sorting Things To Know Be able to recognize and follow an insertion sort, selection sort, and bubble sort Understand their pros and cons Know that many other sorts exist with varying efficiency and programming difficulty Sorting animations (in Java of course!) http://www.cs.hope.edu/~alganim/animator/Animator.html

36. Question Given the operation of the following sort, identify the type of sort (selection, insertion, or bubble) 3421971587 2134971587 2134159787 2134158797 2115348797 1521348797 original pass 1 pass 2 pass 3 pass 4 pass 5 SORTED

37. Question Given the operation of the following sort, identify the type of sort (selection, insertion, or bubble) 3421971587 2134971587 1521349787 1521348797 original pass 1 pass 2 pass 3 pass 4 SORTED

38. Sorting Things Other Than Numbers characters –same as integers (compare with ) Strings –use the built-in compareTo method Other Objects –we write a compareTo method –use the compareTo method