1. Chapter 4
Unordered List

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. 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. 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. 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. 4.1 Unordered List Properties

7. 4.1 Unordered List Properties

8. 4.1 Unordered List Properties
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?
What is the itemwise breakup of expenditure?
What is the total amount spent in a given time period?
All these question may be answered by scanning such a list from the beginning and terminating when our question is answered.

9. 4.1 Unordered List Properties

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. 4.2 Sequential Search

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

13. 4.2.1 Average Case Analysis
It takes Ci comparisons to find success at the i-th element, then the average number of comparisons is simply:

14. 4.2.1 Average Case Analysis
It takes i comparisons to succeed at the i-th element, i.e. Ci=i
Assumption:
We are assuming that any element is searched for with the same likelihood as any other. In other words, if there are n elements, we are assuming that any one element has a 1/n chance or probability to being searched.

15. 4.2.1 Average Case Analysis
Example for which we do not make this assumption:

16. 4.2.1 Average Case Analysis

17. 4.2.1 Average Case Analysis
Note that if we assume equal search probabilities, Pi would be 1/n. For sequential search on an unordered list, we would then arrive at (n + 1)/2 for the average number of comparisons, which tallies with one of the intuitive guesses.

18. 4.2.2 Rearranging Data Based on Search Patterns
We would pay the lowest cost for the average number of comparisons if we were to arrange the elements from first position to last position based on decreasing search probabilities.

19. 4.2.2 Rearranging Data Based on Search Patterns
Assumed that the search probabilities are all known beforehand.
If a search is made for element x of the list, then, after this element is found in the list, it is simply moved to the front of the list.
The more often an entry is searched for, the more towards the front of the list it will be.

20. 4.3 A List Class
NoSuchElementException thrown back.

21. 4.3 A List Class

22. 4.3 A List Class

23. 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.

24. 4.3 A List Class
Example that enumerates:

25. 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.

26. 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, the date of expense, and the item on which the expense was incurred.

27. 4.4.1 Expense Class Interface

28. 4.4.1 Expense Class Interface

29. 4.4.2 Expense Class

30. 4.4.2 Expense Class

31. 4.4.2 Expense Class

32. 4.4.3 ExpenseList Class Interface

33. 4.4.3 ExpenseList Class Interface

34. 4.4.4 ExpenseList Class Implementation

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

36. 4.4.4 ExpenseList Class Implementation
Time requirement of each of these methods is O(n).
amountSpentOn and amountSpentDuring involve sequential search.
Both methods are O(n)

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

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

39. 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 time, amount, and date.
What if we wanted to know whether we had incurred any expense on a particular day, say 2005/2/15?
We would need to redefine the equality of expenses in terms of date only.

40. 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.

41. 4.4.5 Equality of Objects and Searching

42. 4.4.5 Equality of Objects and Searching
Subclasses DateExpense and ItemDateExpense are defined in an analogous manner, differing in their definitions of the equals method.

43. 4.4.5 Equality of Objects and Searching
Searching in ExpenseList

44. 4.4.5 Equality of Objects and Searching
An ItemExpense object, itemExp, is sent as actual argument to method contains in ExpenseList.
An Expense object, nextExpense, is picked up from budget.
This nextExpense object is shipped as the actual argument to the equals method of itemExp.

45. 4.4.5 Equality of Objects and Searching
It is crucial to ask for an instance of Expense, and not of ItemExpense.
Budget list is populated with Expense objects, not ItemExpense objects.

46. 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.
A DateExpense date field would participate in equality checking.
An ItemDateExpense: item and date

47. 4.4.5 Equality of Objects and Searching

48. 4.4.5 Equality of Objects and Searching
Only send in the key part, date 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.

49. 4.5 Linked List

50. 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.

51. 4.5 Linked List

52. 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.

53. 4.5.1 Node

54. 4.5.1 Node A node is defined in terms of itself:
next field of the node class is a reference to another Node<T> object.
Self-referential structure

55. 4.5.2 Insertion
Adding to the beginning of the list.

56. 4.5.2 Insertion
Adding in between two nodes.

57. 4.5.2 Insertion
Adding to the end of the list

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

59. 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.

60. 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.

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

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

63. 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.

64. 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.

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

66. 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.

67. 4.5.5 Circular Linked List
Assumes the list is not empty.

68. 4.6 A LinkedList class

69. 4.6 A LinkedList class

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

71. 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.

72. 4.6 A LinkedList class

73. 4.6 A LinkedList class

74. 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.

75. 4.6 A LinkedList class

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

77. 4.6 A LinkedList class

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

79. 4.6 A LinkedList class

80. 4.6 A LinkedList class

81. 4.6 A LinkedList class

82. 4.6 A LinkedList class

83. 4.6 A LinkedList class

84. 4.6 A LinkedList class

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

86. 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.

87. 4.7 List Class Implementation

88. 4.7 List Class Implementation

89. 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

90. 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.

91. 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, Pi=1/n.

92. 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.

93. 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.

94. 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.