Lists
Ellen Walker
CPSC 201 Data Structures
Hiram College
What is a List (abstract)?
• Sequence of objects
• Objects are in order
– There is a first object
– There is a last object
– Each object (except last) has a successor
– Each object (except first) has a predecessor
• List can be changed
– Objects can be added (list grows)
– Objects can be removed (list shrinks)
Some Operations on a List
• Construct a new list
• Add an element
– Indicate where (beginning, end, middle?)
• Remove an element
– Indicate which one (how?)
• Find an element in the list
• Check whether the list is empty or not
• (etc)
List vs. Array
• List is more general than array
– List is abstract, array is an implementation
• List is more flexible than array
– List can grow or shrink; array is fixed size
• List contains Objects, array can contain base
types
– Use wrappers (e.g. Integer) with boxing/unboxing
in a List
List Class Hierarchy
Choosing an Implementation
• Any implementation will implement all
methods of the interface (by definition)
• But
– Some implementations might be more efficient at
some operations
• Example:
– Removing element from middle of list
• ArrayList: shift all elements to fill the “hole” - O(N)
• LinkedList: adjust successor of element before the
removed one O(1)
ArrayList Implementation
• The list is stored in an array, which is a
private member of the ArrayList (you cannot
access it)
• This array has a capacity
• When the number of elements in the list
exceeds the capacity, the internal array is
replaced by a bigger one
Constructing an ArrayList
• ArrayList()
– Constructs initially empty list, capacity of 10
• ArrayList(int capacity)
– Constructs initially empty list with given capacity
• Example: Both lists are empty (size of 0), but
A has capacity of 10, and B has capacity of 5
– ArrayList A = new ArrayList();
– ArrayList B = newArrayList(5);
Specifying Element Types
• Generics - specify element type in
//Construct an ArrayList that holds strings
List myList = new ArrayList ();
//An ArrayList of Circles
List myList = new ArrayList();
• Without type specification, Object is assumed
– Backwards compatible with Java before 5.0
Why Generic Collections?
• Old-style needs casting, compiler cannot
check
– List myList = new ArrayList();
– myList.add(new Integer(5)); //any Object is OK
– System.out.println((String) myList.get(0)); //runtime
error: cannot cast Integer to String
• Generic - Compiler error
– List myList = new ArrayList();
– myList.add(new Integer(5)); //compiler error - type
mismatch
Why Generic Collections?
• Old-style: Objects must be explicitly wrapped
List List1 = new ArrayList();
List1.add(5); //error
• Generic: Autoboxing takes care of it
List List1 = new ArrayList();
List1.add(5); //new Integer(5) created and inserted
Adding Elements
• For an ArrayList
– ArrayList rainbow = new ArrayList (5);
• add (E obj) - adds obj to the end of the list
– rainbow.add(“green”);
– rainbow.add(“violet”);
• add (int index, E obj) - adds obj at position index of
the list
– rainbow.add(0, “red”)
– rainbow.add(2, “blue”);
Accessing and Changing Elements
• Use get() and set() instead of [ ] for ArrayLists
– More general (works for other list types)
• Get method
– aColor = rainbow.get(1);
– for(int c=0;c
System.out.println(rainbow.get(c));
• Set method
– rainbow.set(1, “Crimson”);
Summary: Java ArrayList
More examples
• What add statements are needed to complete
the rainbow? (red, orange, yellow, green,
blue, indigo, violet)
• What statement will change “indigo” to
“purple”?
• What will rainbow.indexOf(“orange”) return?
• What will rainbow.indexOf(“elephant”) return?
Application vs. Implementation
• We now know enough to apply the ArrayList
class, but…
• To really understand an ADT, we should
learn about its implementation
• We will implement classes similar to each of
the collection classes we study
– ArrayList vs. KWArrayList
– LinkedList vs. KWLinkedList
…
Implementation of an ArrayList Class
• KWArrayList: simple implementation of a
ArrayList class
– Physical size of array indicated by data field
capacity
– Number of data items indicated by the data field
size
Implementation of an ArrayList Class
(continued)
Overview of KWArrayList
• Data Members
– Private static final int INITIAL_CAPACITY = 10;
– Private E[ ] theData; //array for data
– Private int size = 0; //current size
– Private int capacity = 0; //current capacity
• Default constructor
– Sets capacity and creates an array for theData
Overview of KWArrayList (cont)
• Public boolean add (E anEntry)
– Check if the array is full; if so then reallocate
– theData[size] = anEntry;
– Increment size
• Public boolean add (int index, E anEntry)
– Check if the array is full; if so then reallocate
– Shift elements beyond index to make room
– theData[index] = anEntry
– Increment size
Overview of KWArrayList (cont)
• Public E remove(int index)
– Shift all items after index left by one space
– Decrement size
– Return the element that was removed
• Private void reallocate ()
– Double the capacity
– Create a new array of the appropriate size
– Copy all the data into the new array
Cost of Reallocation
• Every time we reallocate, we copy capacity entries
into the new array (of size 2*capacity)
• Cost is proportional to the capacity (C*capacity)
• Since we reallocate only after adding capacity items
we have:
– Capacity -1 additions (0 extra cost)
– 1 addition (C*capacity extra cost)
• Averaging it out, the extra cost is constant per
addition
Performance of KWArrayList
• Set and get methods execute in constant time
• Inserting or removing elements is linear time
– What is worst case of removing an element?
– What is worst case of inserting an element? (Hint:
consider capacity of the list)
• IndexOf is linear time