Lists

Ellen WalkerCPSC 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 stringsList<String> myList = new ArrayList<String> ();

//An ArrayList of CirclesList<Circle> myList = new ArrayList<Circle>();

• 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<String> = new ArrayList<String>();

– myList.add(new Integer(5)); //compiler error - type mismatch

Why Generic Collections?

• Old-style: Objects must be explicitly wrappedList List1 = new ArrayList(); List1.add(5); //error

• Generic: Autoboxing takes care of itList<Integer> List1 = new ArrayList<Integer>(); List1.add(5); //new Integer(5) created and inserted

Adding Elements

• For an ArrayList<E>– ArrayList<String> rainbow = new ArrayList<String> (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<rainbow.size();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