Presentation is loading. Please wait.

Presentation is loading. Please wait.

Chapter 11 Array-Based Lists. 2 Knowledge Goals Understand the list abstraction and basic list operations Recognize the difference between an array and.

Similar presentations


Presentation on theme: "Chapter 11 Array-Based Lists. 2 Knowledge Goals Understand the list abstraction and basic list operations Recognize the difference between an array and."— Presentation transcript:

1 Chapter 11 Array-Based Lists

2 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 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 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 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 6 What is a List? Sorted list: The predecessor and successor relation- ships are determined by the content of the keys Key

7 7 What is a List? We are concerned only with unique keys

8 8 A List Class Can you name some of the operations that must be applied to a List?

9 9 A List Class

10 10 A List Class Transformers add remove Observers isEmpty isFull size contains hasNext Iterators resetList next change state observe state process components

11 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 12 A List Class

13 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 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 15 A List Class public boolean isEmpty() { return (numItems == 0) } public int size() { return numItems; } public boolean isFull() { return (numItems == listItems.length); } observers

16 16 A List Class public boolean contains(String item) { int index = 0; while (index < numItems && listItems[index].compareTo(item) != 0) index++; return (index < numItems); } See why this works?

17 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 item in numItems location and increment numItems item 63

18 18 After Inserting 64 into an Unsorted List numItems 4 listItems [ 0 ] 15 [ 1 ] 39 [ 2 ] -90 [ 3 ] [ listItems.length-1 ] item 64

19 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 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 21 Can you walk through deleting 39? numItems 4 listItems [ 0 ] 15 [ 1 ] 39 [ 2 ] -90 [ 3 ] 64. [ listItems.length-1 ]

22 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 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; } Read documentation carefully!

24 24 A List Class How are CRC cards and UML diagrams alike? How are they different?

25 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 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 A command- driven testing program

27 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 are resetList, hasNext, and next tested ?

28 28 ListWithSort Sorting Arranging the components of a list into order

29 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 30 ListWithSort

31 31 ListWithSort Can you use the same test driver ?

32 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 33

34 34 A Sorted List

35 35 A Sorted List Add

36 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 37 A Sorted List remove and next must maintain order but they already do!

38 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 39 Searching [0][1][2][3][4][5] How many comparisons are needed to find 11? 67? 2? 100? [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 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 41 Searching

42 42 Searching Boolean Binary Search (first, last) If (first > last) return false Else Set middle to (first + last)/2 Set result to item.compareTo(list[middle]) If (result is equal to 0) return true Else If (result < 0) Binary Search (first, middle - 1) Else Binary Search (middle + 1, last)

43 43 Searching Searching for "bat"

44 44 Searching

45 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 46 Searching Is a binary search always better? LengthSequentialBinary , , Average Number of iterations

47 47 Refactoring the List Hierarchy Refactoring Modifying code to improve its quality without changing is functionality There is a better way!

48 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 49 Refactoring the List Hierarchy

50 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 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 52 List of Comparable Objects public 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 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 lists before mentioning the Java Collections?

54 54 Preview of Java Collections ArrayList (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 isEmptyReturns 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 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 56 while (inFile.hasNextLine()) { line = inFile.nextLine(); list.add(line); } // Declare and instantiate iterator Iterator iterator = list.iterator(); while (iterator.hasNext()) System.out.println(iterator.next()); inFile.close(); outFile.close(); } Preview of Java Collections different look closely

57 57 Extras - GUI Track

58 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 59 Extras - GUI Track Three instances of class containing panel

60 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 61 Extras - GUI Track Window with three buttons and one listener


Download ppt "Chapter 11 Array-Based Lists. 2 Knowledge Goals Understand the list abstraction and basic list operations Recognize the difference between an array and."

Similar presentations


Ads by Google