Lists • We’ve seen an array-based list implementation, the ArrayList. • Advantage of an array-based implementation: – fast access to a specific index – typically less space usage than other options • Disadvantage of an array-based implementation: – can be expensive to insert items – resizing is an expensive operation
30
Embed
Lists We’ve seen an array-based list implementation, the ArrayList. Advantage of an array-based implementation: –fast access to a specific index –typically.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Lists
• We’ve seen an array-based list implementation, the ArrayList.
• Advantage of an array-based implementation:– fast access to a specific index– typically less space usage than other options
• Disadvantage of an array-based implementation:– can be expensive to insert items– resizing is an expensive operation
Amortization
• Resizing of array-based data structures involves a tradeoff:– many insertions (as in our Bag) are very
efficient since no allocation of space is required (an array is allocated as a big block of memory)
– some insertions (as in our Bag) are very expensive since resizing must take place
Linked List
• A linked list is a list implementation which spreads out the cost of space allocation evenly to all insertions.
• Each insertion involves allocation of space
Advantages/Disadvantages
• Advantages– predictable cost of insertion– efficient insertion at any point in structure
• Disadvantages– extra space required to store links– inefficient indexing
Comparison of storage
A pair has a first and a second element
When pairs are used to construct lists,the first is called the “head” or the “car”the second is called the “tail”, “rest” or “cdr”the pair is called a “cons cell” or simply a “cons”.
Linked list implementations
• Textbook discusses a typical linked list implementation
• java.util.LinkedList is another typical implementation
• These implementations have procedural, not object-oriented, roots.
Traditional implementations
• provide a large number of methods – making it difficult to reuse if less functionality is desired;
• provide no means, beyond inheritance, to extend functionality to suit a specific situation; and
• adding functionality requires knowledge of internal structure of the list.
So…
• These implementations are inflexible, and do not exhibit good OO design.
• In lecture we will discuss a state-based list implementation which can be easily extended with new functionality.
Variant/Invariant decomposition
• Design principle which leads to cohesive and decoupled components
• That which is invariant is put into one component• Variant properties/behaviors are factored out into
separate components• Compare this to what we saw with e.g. Observer pattern:
– decoupling of event generation (invariant) from event handling (variant)
a list = a Linear Recursive Structure(LRS or LRStruct)
• What is a list?1. the empty list is a list2. a pair whose tail is a list is itself a list
• This is a recursive definition! (1) is called the base case, and (2) is called the recursive case.
• Note that traditional implementations do not follow this precise definition of what a list is:
– many have no explicit representation of an empty list– none are recursive on the list; instead they recurse on a list node
• This has implications for how the structure can support extension (see Visitor support, in later slides)
States
• A list can therefore be in one of two states:– empty (corresponding to the base case)– non-empty (corresponding to the recursive case)
• The state-based implementation we will study makes this distinction explicit in the representation
Empty vs. NonEmpty state(look Ma, no NullPointerException!)• An LRS object delegates all calls to its LRS
State object – which can respond to all messages.
• Empty and NonEmpty states respond differently.
• There is never a null pointer in the structure! (Think about the implications of this for a while.)
What is basic (invariant) list functionality?
• insert new item at front
• remove item from front
• set/get first item (head)
• set/get rest (tail)
• plus (in Java) methods inherited from Object (toString, equals, etc)
How are these methods defined?
public LRStruct<E> insertFront(E item) {
return _state.insertFront(this, item);}public E removeFront() {