1. 1 Chapter 4 Unordered List

2. 2 Learning Objectives ● Describe the properties of an unordered list. ● Study sequential search and analyze its worst- case and average running times. ● Discover how the entries of a list may be dynamically rearranged at achieve better search times. ● Understand the public interface of an unordered list class in Java and the running times of its methods.

3. 3 Learning Objectives ● Develop a set of classes for an expense processing application based on an unordered list. ● Understand how object-oriented programming can be used to write a single piece of code in Java that can perform equality checking based on different criteria for different input objects. ● Learn what linked lists are, why they are useful, and how to build and manipulate them.

4. 4 Learning Objectives ● Implement a linked lest class in Java and analyze the running times of its methods. ● Implement an unordered list class in Java using a linked list component.

5. 5 4.1 Unordered List Properties ● Keeping track of daily expenses.  It would be useful to write a program that maintains an expense list of all recorded expenses, that can be used to find quick answers to simple budgeting type questions.

6. 6 4.1 Unordered List Properties

7. 7

8. 8 ● Answer the following questions:  What is the maximum (or minimum) expense, and on what item?  What is the average expense?  What is the total amount spent on a given item? ● All these question may be answered by scanning such a list from the beginning and terminating when our question is answered.

9. 9 4.1 Unordered List Properties

10. 10 4.2 Sequential Search ● Operation contains searches for a specific itme in the list.  Since the list is unordered, the only way to conduct the search is to look at every element in the sequence.  If a match is found, the operation returns true, otherwise it returns false.

11. 11 4.2 Sequential Search

12. 12 4.2 Sequential Search ● Best case  1 ● Worst case  n ● Unsuccessful search?  n

13. 13 4.3 A List Class ● NoSuchElementException thrown back.

14. 14 4.3 A List Class

15. 15 4.3 A List Class

16. 16 4.3 A List Class ● Enumeration  The items of a List object may be enumerated with a simple device called a cursor. ● To start, a call is made to the first method. ● This sets the cursor at the first item of the list, and returns that item. ● Every subsequent call to the next method moves the cursor to the next item, and returns that item. ● When the cursor is at the end of the list, any subsequent call to next will return null.

17. 17 4.3 A List Class ● Example that enumerates:

18. 18 4.3 A List Class ● Running times  An implementation should be able to access the last item of the list in O(1) time, so that the add method may be implemented in O(1) time.  Maintain a count of the number of items in the list. ● The size method can then simply return this count.  Empty the list in O(1) time.  Use a cursor to enumerate a list, so that each of the enumeration methods first and next may be implemented in O(1) time.

19. 19 4.4 An ExpenseList Class Using List ● An ExpenseList class would support operations for maintaining expenses.  Use the generic List class as a component, implementing all the ExpenseList class methods by reusing code from one or more of the appropriate List class methods.  Every expense will consists of the amount of expense and the item on which the expense was incurred.

20. 20 4.4.1 Expense Class Interface

21. 21 4.4.1 Expense Class Interface

22. 22 4.4.2 Expense Class

23. 23 4.4.2 Expense Class

24. 24 4.4.3 ExpenseList Class Interface

25. 25 4.4.3 ExpenseList Class Interface

26. 26 4.4.4 ExpenseList Class Implementation

27. 27 4.4.4 ExpenseList Class Implementation ● minExpense, and aveExpense scan every expense entry in the list.

28. 28 4.4.4 ExpenseList Class Implementation ● Time requirement is O(n).  amountSpentOn involve sequential search.

29. 29 4.4.4 ExpenseList Class Implementation ● Returns a matching Expense object from the expense list. ● If they are different, how come they match?

30. 30 4.4.5 Equality of Objects and Searching ● Rewrite the method by implementing a search in the method.

31. 31 4.4.5 Equality of Objects and Searching ● The notion of equality is defined by the equals method of the exp object.  Two expenses are equal if they have the same amount and item.  What if we wanted the equality based only on the item so if two expenses have the same item with different amount they are equal.  We would need to redefine the equality of expenses in terms of item only.

32. 32 4.4.5 Equality of Objects and Searching ● Class Specialization for Special Equality  Define special classes that extend the Expense class, with the sole aim of implementing special, and different, kinds of expenses.

33. 33 4.4.5 Equality of Objects and Searching ● About Keys  The get method is useful to extract an entire object from the list by matching its key part with a specified key.

34. 34 4.4.5 Equality of Objects and Searching ● Only use the key part, (ex item )and get returns the entire matching entry (including amount), if any.  What data structure should be used to store the items in a list? ● Removing items from anywhere in the list.  Leaves holes in the array.  Uses more space than necessary.  Search times would be greater than O(n). ● If the holes are patched up by compacting the array, we would be doing a lot of data movement within the array.

35. 35 4.5 Linked List

36. 36 4.5 Linked List ● To access the entries of the linked list, a reference to its first entry is all we need.  One can access any entry by simply following the chain of links.  When an entry is removed from some place in a linked list, all that needs to be done is to have its predecessor's link refer to its successor.  Similarly, an entry may be inserted anywhere in the list without having to move other entries over to create space.

37. 37 4.5 Linked List

38. 38 4.5 Linked List ● The biggest drawback of the linked list is its inability to perform random accesses for any entry in a single step.

39. 39 4.5.1 Node

40. 40 4.5.1 Node ● A node is defined in terms of itself:  next field of the node class is a reference to another Node object.  Self-referential structure

41. 41 4.5.2 Insertion ● Adding to the beginning of the list.

42. 42 4.5.2 Insertion ● Adding in between two nodes.

43. 43 4.5.2 Insertion ● Adding to the end of the list

44. 44 4.5.3 Deletion ● Deleting the first node, the last node, or in- between node.

45. 45 4.5.3 Deletion ● In both insertion and deletion we assumed the existence of P, a reference to the node just prior to the one to be inserted or deleted.

46. 46 4.5.4 Access ● Stepping through, or traversing, all the entries of a linked list from beginning to end following the chain of references is a useful operation in practice.

47. 47 4.5.4 Access ● Deleting the first occurrence of the string “Carrot”.

48. 48 4.5.4 Access ● We can't delete nextNode unless we have a reference to the node prior to it.

49. 49 4.5.5 Circular Linked List ● It is useful to have instant access to both the first and the last entries of a linked list.

50. 50 4.5.5 Circular Linked List ● Given that L refers to the last entry, the first entry is simply L.next.  if L==L.next, that means there is exactly one entry in the CLL.

51. 51 4.5.5 Circular Linked List ● Insertion  Inserting a new node as the first entry?  Will not work if the list is empty.

52. 52 4.5.5 Circular Linked List ● Deletion  Deleting the last node.  Wee need to have access to the node preceding it.  Assume that P is this predecessor node, and that it has already been located.  Assumes there are at least two nodes in the list.  The termination condition is that the scanning pointer returns to the starting position.

53. 53 4.5.5 Circular Linked List ● Assumes the list is not empty.

54. 54 4.6 A LinkedList class

55. 55 4.6 A LinkedList class

56. 56 4.6 A LinkedList class ● Class methods may be classified according to functionality.

57. 57 4.6 A LinkedList class ● Running times  Basic unit time operations that count toward the running: ● Retrieving a reference, as in Node x = p.next ● Updating a reference, as in p.next = x ● Retrieving or updating the size (number of items) of the linked list ● Comparison between a pair of data items stored in the linked list.

58. 58 4.6 A LinkedList class

59. 59 4.6 A LinkedList class

60. 60 4.6 A LinkedList class ● Since the Node class is used as an inner class, the generic type parameter T for the LinkedList class is already known to Node, and must not be repeated in the Node class.  The fields tail makes it clear that this class is implemented as a circular linked list.

61. 61 4.6 A LinkedList class

62. 62 4.6 A LinkedList class ● After the insertion, the old entry is at i + 1.

63. 63 4.6 A LinkedList class

64. 64 4.6 A LinkedList class ● We need to be sure that the tail variable has a legal value before the method terminates.

65. 65 4.6 A LinkedList class

66. 66 4.6 A LinkedList class

67. 67 4.6 A LinkedList class

68. 68 4.6 A LinkedList class

69. 69 4.6 A LinkedList class

70. 70 4.6 A LinkedList class

71. 71 4.6 A LinkedList class ● get is identical in logic to the indexOf method except that it returns the matching item if found.

72. 72 4.7 List Class Implementation ● Review  Started with the List interface, using it to build an ExpenseList class.  To implement the List class use an array or the java.util.ArrayList class would not be a good choice.  The LinkedList class, on the other hand would be ideal.  The ExpenseList class implementation uses the List class as a component, the List class is built using the LinkedList class as a compenent.

73. 73 4.7 List Class Implementation

74. 74 4.7 List Class Implementation

75. 75 4.8 Summary ● The unordered list is a linear collection of entries whose relative positions with respect to each other is irrelevant. ● The unordered list is characterized by four main operations:  Append  Remove  Enumerate  Search

76. 76 4.8 Summary ● An entry is searched for in a unordered list using sequential search. ● In sequential search, a target is compared against every entry in the list in sequence, one after the other. ● The average number of comparisons for successful search in a data structure is the number of comparisons required.

77. 77 4.8 Summary ● The average number of comparisons for successful search in a data structure is given by the formula: ● In the absence of specific information about probabilities, each element is assumed to e searched with the same probability as any other element, P i =1/n.

78. 78 4.8 Summary ● The lowest number of comparisons on the average for successful search in a list is obtained if the entries of the list are arranged in decreasing order of search probabilities. ● The notion of the equality of objects is specific to a client, and is implemented in a client class by overriding the default implementation. ● The key part of an object is that which is used as the basis of comparing against another object for equality.

79. 79 4.8 Summary ● A linked list is a linear structure consisting of nodes. ● The linked list's main advantage over an array is that space for nodes is allocated only when needed. ● Inserting a node into or deleting a node from a linked list follows a strict sequence. ● A circular linked list is one in which the last node refers back to the first.

80. 80 4.8 Summary ● An unordered list class may be implemented using a linked list object as component. ● Code reuse by composition is also demonstrated in the implementation of the ExpenseList class, which uses an unordered list component.