View
214
Download
0
Category
Tags:
Preview:
Citation preview
Chapter 11Array-Based Lists
2
Knowledge Goals• Understand the list abstraction and basic list
operations• Recognize the difference between an array and a
list• Understand how to use an array to represent a
list• Know how to use a key to establish the order of a
sorted list• Understand the principle of "divide and conquer"
as expressed in the binary search algorithm
3
Skill Goals
• Add an item to a list• Remove an item from a list• Search for an item in a list• Sort the items in a list into ascending or
descending order• Build a list in sorted order• Search for an item in a sorted list using a
linear search
4
Skill Goals
• Search for an item using a binary search• Define a class that extends a Java
interface• Use Java's Comparable interface• Use ArrayList from the Java library
5
What is a List?
List
A homogeneous collection of elements, with a linear relationship between the elements
Linear relationship
Every element (except the first) has a unique predecessor, and every element (except the last) has a unique successor
Length (size in Java)
The number of items in a list; it can vary over time
6
What is a List?
Sorted list: The predecessor and successor relation-ships are determined by the content of the keys
Key
Key
7
What is a List?
We are concerned only with unique keys
8
A List Class
Can you name some of the operations that must be applied to a List?
9
A List Class
10
A List Class
Transformers add remove
Observers isEmpty isFull size contains hasNext
Iterators resetList next
change state
observe state
process components
11
A List Class
Attributes
numItems
listItems[0]
. . .
listItems[listItems.length-1]
currentPos
number of elements in list
array of list elements
used by iterator
12
A List Class
13
A List Class
UNSORTED LIST
Elements are placed into the list in no particular order with respect to their content
SORTED LIST
List elements are in an order that is sorted by the content of their keys -- either numerically or alphabetically
Class ListOfStrings is unsorted
14
A List Class
public ListOfStrings() { numItems = 0; listItems = new String[100]; currentPos = 0;}
public ListOfStrings(int maxItems) { numItems = 0; listItems = new String[maxItems]; currentPos = 0;}
constructors
15
A List Class
public boolean isEmpty()
{
return (numItems == 0)
}
public int size()
{
return numItems;
}
public boolean isFull()
{
return (numItems == listItems.length);
}
observers
16
A List Classpublic boolean contains(String item)
{
int index = 0;
while (index < numItems &&
listItems[index].compareTo(item) != 0)
index++;
return (index < numItems);
}
See why this works?
17
Add: Does it matter where we put the item?
numItems 3
listItems [ 0 ] 15
[ 1 ] 39
[ 2 ] -90
[ 3 ] .
. . [ listItems.length-1 ]
Place the itemin numItems location and increment numItems
item 63
18
After Inserting 64 into an Unsorted List
numItems 4
listItems [ 0 ] 15
[ 1 ] 39
[ 2 ] -90
[ 3 ] 64 .
. . [ listItems.length-1 ] item 64
19
public void add(String item)// Result: If the list is not full, puts item as// the last position in the list; otherwise list// is unchanged{ if (!isFull()) {
listItems[numItems] = item;
numItems++; }}
A List Class
20
A List class
remove(item)
Search (item, found, index)
if (found)
Shift remainder of list up
Decrement numItems
Remove is more difficult
ShiftUp
for count going from index downTo numItems
Set listItems[count] to listItems[count+1]
21
Can you walk through deleting 39?
numItems 4
listItems [ 0 ] 15
[ 1 ] 39
[ 2 ] -90
[ 3 ] 64 .
. . [ listItems.length-1 ]
22
public void remove(String item) { int index = 0; boolean found = false; while (index < numItems && !found) { if (listItems[index].compareTo(item) == 0) found = true; else index++; } if (found) { for (int count = index; count < numItems - 1; count++)
listItems[count] = listItems[count + 1];
numItems--; }}
The List Class
23
public void resetList() { currentPos = 0; } public boolean hasNext() { return (currentPos != numItems); }
public String next()// Returns the item at the currentPos position// Assumptions: No transformers are called during the // iteration
A List Class
{
String next = listItems[currentPos]; currentPos++; return next;}
Readdocumentation
carefully!
24
A List Class
How areCRC cardsand UMLdiagrams
alike?How are
theydifferent?
25
A List Class
A class is not complete until
it has been tested!
Command-driven test driver
A driver program that reads in commands and executes them; an excellent vehicle for unit testing a class
enum Operations {ADD, REMOVE, SIZE, ISEMPTY, ISFULL, CONTAINS, PRINT, QUIT}
26
A List Class
Main
Read file into list
Set operation to inOperation()
Set keepGoing to true
while (keepGoing)
Execute operation
Set operation to inOperation
Write list to file
Acommand-
driventesting
program
27
A List Class
executeOperation
switch(operation)
case ADD: // execute add
case REMOVE: // execute remove
case SIZE: // execute size
case ISEMPTY: // execute isEmpty
case ISFULL: // execute isFull
case CONAINS: // execute contains
case PRINT: // print list
case QUIT: // quit
How areresetList,hasNext,and next
tested?
28
ListWithSort
Sorting
Arranging the components of a list into order
29
ListWithSort
Straight selection sort Examine the entire list to select the smallest element Swap that element with first element (with array index 0) Examine the remaining list to select the smallest
element from it Swap that element with second element (array index 1) Continue process until only 2 items remain Examine the last 2 remaining list elements to select the
smallest one Swap that element with the other
30
ListWithSort
31
ListWithSort
Canyou use
the sametest
driver?
32
A Sorted List
Is ListWithSort the same as a SortedList?
Are the same operations needed for a List and a SortedList? Any extra ones needed?
From the client's (user's) point of view, what is the visible difference between an unsorted list and a sorted list?
33
34
A Sorted List
35
A Sorted List
Add
36
public void add(String item){ if (! isFull()) {// find proper location for new element
int index = numItems - 1;
while (index >= 0 &&
item.compareTo(listItems[index]) < 0) { listItems[index + 1] = listItems[index]; index--; } listItems[index +1] = item; // insert item numItems++; }}
A Sorted List
37
A Sorted List
remove andnextmust
maintainorder
but theyalready
do!
38
Searching
Linear (sequential) search
Search begins at the beginning of the list and continues until the item is found or the entire list has been searched
Can searching be improved if the items are in sorted order?
39
Searching
3 34 7 99 66 11
[0] [1] [2] [3] [4] [5]
How many comparisons are needed to find 11? 67? 2? 100?
3 7 11 34 66 99
[0] [1] [2] [3] [4] [5]
How many comparisons are needed to find 11? 67? 2? 100?
That's better, but we can do better yet
40
Searching
Binary search (list must be sorted)Search begins at the middle and finds the item or eliminates half of the unexamined items; process is repeated on the half where the item might be
Say that again…
41
Searching
42
Searching
Boolean Binary Search (first, last)If (first > last)
return falseElse
Set middle to (first + last)/2Set result to item.compareTo(list[middle])If (result is equal to 0)
return trueElse
If (result < 0)Binary Search (first, middle - 1)
ElseBinary Search (middle + 1, last)
43
Searching
Searching for "bat"
44
Searching
45
public boolean isThere(String item) // Assumption: List items are in ascending order// Returns true if item is in the list; false otherwise{ int first = 0; int last = numItems - 1; int middle; boolean found = false; while (last >= first && !found) { middle = (first + last) / 2; if (item.compareTo(listItems[middle]) == 0) found = true; // Item has been found else if (item.compareTo(listItems[middle] < 0) last = middle - 1; // Look in first half else first = middle + 1; // Look in second half } return found;}
Searching
46
Searching
Is a binary searchalways better?
Length Sequential Binary
10 5.5 2.9
100 50.5 5.8
1,000 500.5 9.0
10,000 5000.5 12.0
Average Number of iterations
47
Refactoring the List Hierarchy
Refactoring
Modifying code to improve its quality without changing is functionality
Thereisa
betterway!
48
Refactoring the List Hierarchy
public abstract class AbstractList{ public AbstractList() public AbstractList(int maxItems) public boolean isFull() public boolean isEmpty() public int size() public void resetList() public boolean hasNext() public String next() public boolean contains(String item) public abstract void remove(String item) public abstract void add(String item)}
What about contains?
49
Refactoring the List Hierarchy
50
List of Comparable Objects
Wouldn't it be nice if we could have one abstract class for any data type, not one for each type of item that could be on the list?
You can if you declare the type of the items to be Comparable
protected Comparable[] listItems
51
List of Comparable Objects
public abstract class AbstractList{ public AbstractList() public AbstractList(int maxItems) public boolean isFull() public boolean isEmpty() public int size() public void resetList() public boolean hasNext() public String next() public boolean contains(Comparable item) public abstract void remove(Comparable item) public abstract void add(Comparable item)}
52
List of Comparable Objectspublic AbstractList(){ numItems = 0; listItems = new Comparable[100]; currentPos = 0;}
public void add(Comparable item){ if (!isFull()) { listItems[numItems] = (String) item; numItems++; }}
Abstract class
Derived class
53
Preview of Java Collections
Java Collections
A collection of interfaces, abstract classes, and classes available in java.util that describe data structures available for you to use
Why do you think we covered array-based listsbefore mentioning the Java Collections?
54
Preview of Java CollectionsArrayList<type>(int number)
Returns an array with an initial capacity of number elements.
add(Object anObject) anObject is appended to the end of the list
size() Returns the number of elements
remove(Oject anObject)
Removes an instance of anObject if it is there
isEmpty Returns true of the list contains no elements
contains(Object,
anObject)
Returns true if anObject is in the list
iterator() Returns an Iterator over the elements of the list
Plus lots more that are different
55
Preview of Java Collections
import java.util.*;import java.io.*;public class ListDriver{ private static Scanner inFile; private static PrintWriter outFile; public static void main(String[] args) throws
IOException { inFile = new Scanner(new FileReader("list.dat")); outFile = new PrintWriter(new FileWriter("list.out")); ArrayList list = new ArrayList(4); String line;
different
56
while (inFile.hasNextLine()) { line = inFile.nextLine(); list.add(line); }
// Declare and instantiate iteratorIterator iterator = list.iterator(); while (iterator.hasNext()) System.out.println(iterator.next());
inFile.close(); outFile.close(); }}
Preview of Java Collections
differentlook
closely
57
Extras - GUI Track
58
Extras - GUI Track
Handling events from multiple sources with panels requires
declaring and instantiating a JPanel object setting the layout manager for the panel doing everything necessary to create a
button adding the button to the panel declaring and instantiating multiple objects
of the class with the panel
59
Extras - GUI Track
Threeinstancesof class
containingpanel
60
Extras - GUI Track
Handling events from multiple sources with the same listener requires
doing everything necessary to create multiple buttons
handler gets a button's name from actionPerformed parameter
handler uses if statement to determine which button was pressed
61
Extras - GUI Track
Windowwiththree
buttonsand onelistener
Recommended