comp 14 introduction to programming mr. joshua stough april 4, 2005 monday/wednesday 11:00-12:15...
Post on 20-Dec-2015
214 views
TRANSCRIPT
COMP 14Introduction to Programming
Mr. Joshua StoughApril 4, 2005
Monday/Wednesday 11:00-12:15
Peabody Hall 218
Program 5 Announcements• "java.awt.Color.GREEN unrecognized"
error– see Blackboard announcement– re-download BlackjackUI and BlackjackApplet
• Applet works, but cards don't appear– see Blackboard announcement– copy img folder over to your webspace– change IMG_URL to specify the img folder in
your webspace– re-compile and copy BlackjackApplet.class
over to your webspace
COMP 14 Rest of Semester• Today (4/5)
– searching and sorting
• Wed (4/7)– applets, HTML,
and GUIs
• Mon (4/12)– computer graphics
• Wed (4/14)– networking
• Mon (4/19)– data structures
• Wed (4/21)– review for Final
Exam
Declaration vs. Instantiation
public class Dice{ private Die[] dice; // declaration
public Dice(int numDice) {
dice = new Die[numDice]; // instantiationfor (int i=0; i<dice.length; i++) {
dice[i] = new Die();}
}
NOT// declaration and instantiationDie[] dice = new Die[numDice];
creates a new local variable called dice
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 01
2
face 3
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
thisdice
01
2
face 3
Use the debugger in jGRASP!
Declaration vs. Instantiation
• Set a breakpoint
• Compile in debug mode
• Press instead of
• Step through the program and look at the created variables
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());
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());
}}
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
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());
DiceTester.javapublic 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()); }}
Finding Pairs
0 1 2 3 4
How do you pick which ones are pairs?
Remember, a computer can only compare two things at a time.
How do you explain to a small child (or a computer) how to pick which ones are pairs?
Finding Pairs
0 1 2 3 4ind1 ind2
Does Die at ind1 equal Die at ind2?
0 1-4
1 2-4
2 3-4
3 4
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
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
BlackjackUI
• What's going on behind the scenes in Program 5?
• We'll look at user interface code (how things are drawn on the screen) on Wednesday
• What happens when buttons are pressed?
Deal and Quit Buttons
Deal Quit
dealButtonPressed(); System.exit(0);
dealButtonPressed Method• Initializes the hand
– calls BlackjackGame.setupNewHand
• Draws blank cards• Draws the player's cards
– calls BlackjackGame.getPlayerHand– calls getNumCards and getCard in Hand
class
• Draws the player's points– calls BlackjackGame.getPlayerHand– calls BlackjackGame.calcPoints with
Hand parameter
dealButtonPressed (cont.)• Changes the Deal button to Hit button• Enables the Stand button• Changes the instructions• Calls BlackjackGame.playerCanHit to
see if player can add more cards• If player can't add more cards, calls
playerDone method (in BlackjackUI class)– reset instructions– reset buttons
Hit and Stand Buttons
Hit Stand
hitButtonPressed(); standButtonPressed();
standButtonPressed
• Calls playerDone method– reset instructions– reset buttons
hitButtonPressed• Deals a new card to the player
– calls BlackjackGame.addPlayerCard
• Draws the new card– calls BlackjackGame.getPlayerHand– calls getCard in Hand class
• Updates the player's points– calls BlackjackGame.getPlayerHand– calls BlackjackGame.calcPoints with Hand
parameter
• Calls BlackjackGame.playerCanHit to see if player can add more cards
• If the player can't add any more cards, calls playerDone method
New Stuff
• Searching arrays for a particular value– reference: Ch 10 (pgs. 524-526, 537-
542)
• Sorting arrays– makes searching for a particular
value easier (and quicker)– reference: Ch 10 (pgs. 527-534)
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
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
// Linear search of unordered list of integers
// unordered listint[] list = {17, 14, 9, 23, 18, 11, 62, 47, 33, 88};
// look for this value in the listint searchFor = 33;
// Loop thru list until we find matchint 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
// Linear search of unordered list of Strings
// unordered listString[] list = {“Bart”, “Homer”, “Marge”, “Lisa”, “Maggie”, “Millhouse”};
// look for this value in the listString searchFor = “Maggie”;
// Loop thru list until we find matchint 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
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
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 22 26 29 32 37 41 46 50
2 4 5 12 16 19 22 26 29 32 37 41 46 50
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 ~ log2(listLength) – linear
• worst case ~ listLength• average ~ listLength/2
– for 100K words: 17 iterations versus 50,000
• More complex to program
SearchingThings To Know
• Be able to recognize and write a linear search
• Understand its pros and cons
• Know the concepts of a Binary Search
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 search binary searchnumber15
49
98
2
10 3
5 1
10 4
1 3
(49, 10, 17)
(49, 85, 92, 98)(49, 10, 2)
(3, if know list sorted)
Sorting
• Put elements of an array in some order– alphabetize names– order grades lowest to highest
• Two simple sorting algorithms– selection sort– insertion sort
Selection Sort
• Sorts by putting values directly into their final, sorted position
• For each value in the list, the selection sort finds the value that belongs in that position and puts it there
Selection SortGeneral 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
Selection SortAt Work
98 68 83 7493
68 98 83 7493
68 74 83 9893
68 74 83 9893
68 74 83 93 98 SORTED!
Selection Sort
• Sorts in ascending order
• Can be changed to sort in descending order– look for max instead of min
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
Insertion SortGeneral 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
Insertion SortAt Work
98 68 83 7493
68 98 83 7493
68 83 98 7493
68 74 83 98 93
68 74 83 9398
SORTED!
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
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 (listLength2)
Bubble SortAt Work
98 68 83 749368 98 83 749368 83 98 749368 83 74 9893
68 74 83 93 98 SORTED!
68 83 74 9398
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
SortingThings 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
Question
Given the operation of the following sort, identify the type of sort (selection, insertion, or bubble)
34 21 97 15 8721 34 97 15 8721 34 15 97 8721 34 15 87 9721 15 34 87 9715 21 34 87 97
original
pass 1
pass 2
pass 3
pass 4pass 5SORTED
Question
Given the operation of the following sort, identify the type of sort (selection, insertion, or bubble)
34 21 97 15 8721 34 97 15 8721 34 97 15 8715 21 34 97 8715 21 34 87 97
original
pass 1
pass 2
pass 3
pass 4SORTED
SortingThings Other Than Numbers
• characters– same as integers (compare with < and >)
• Strings– use the built-in compareTo method
• Other Objects– we write a compareTo method– use the compareTo method
Next Time in COMP 14
• Discussion of Program 6• Java applets• HTML• GUIs
– how is the Blackjack user interface built?
• Reading Assignment (last one!):– Chapter 6 (pgs. 264-290)– skim Chapter 13 (pgs. 725-806)