Chapter 4

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


7


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


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


12


● Best case 1

● Worst case n

● Unsuccessful search? n

13

4.3 A List Class

● NoSuchElementException thrown back.

14

4.3 A List Class

15

4.3 A List Class

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

4.3 A List Class

● Example that enumerates:

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

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

4.4.1 Expense Class Interface

21

4.4.1 Expense Class Interface

22

4.4.2 Expense Class

23

4.4.2 Expense Class

24

4.4.3 ExpenseList Class Interface

25

4.4.3 ExpenseList Class Interface

26

4.4.4 ExpenseList Class Implementation

27


● minExpense, and aveExpense scan every expense entry in the list.

28


● Time requirement is O(n). amountSpentOn involve sequential search.

29


● Returns a matching Expense object from the expense list.

● If they are different, how come they match?

30

4.4.5 Equality of Objects and Searching

● Rewrite the method by implementing a search in the method.

31


● 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


● 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


● 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


● 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

4.5 Linked List

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

4.5 Linked List

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

4.5.1 Node

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<T> object. Self-referential structure

41

4.5.2 Insertion

● Adding to the beginning of the list.

42

4.5.2 Insertion

● Adding in between two nodes.

43

4.5.2 Insertion

● Adding to the end of the list

44

4.5.3 Deletion

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

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

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

4.5.4 Access

● Deleting the first occurrence of the string “Carrot”.

48

4.5.4 Access

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

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


● 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


● Insertion Inserting a new node as the first entry?

Will not work if the list is empty.

52


● 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


● Assumes the list is not empty.

54

4.6 A LinkedList class

55


56


● Class methods may be classified according to functionality.

57


● 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


59


60


● 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


62


● After the insertion, the old entry is at i + 1.

63


64


● We need to be sure that the tail variable has a legal value before the method terminates.

65


66


67


68


69


70


71


● get is identical in logic to the indexOf method except that it returns the matching item if found.

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


74


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

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

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

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

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

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.

Documents

Chapter 4