CS 46B - Lecture 18

Cover page image

Pre-class reading

Section 16.2
That's in the PDF of the content area, not the printed book

ArrayList Implementation

ArrayList contains a reference to an array—the buffer
Buffer length ≥ array list size

Get/Set

Access array element

private void checkBounds(int n)
{
   if (n < 0 || n >= currentSize) { throw new IndexOutOfBoundsException(); }
}
public Object get(int pos)
{
   checkBounds(pos);
   return buffer[pos];
}

O(1)

Removing

Elements at larger positions shifted down

public Object remove(int pos)
{
   checkBounds(pos);
   Object removed = buffer[pos];
   for (int i = pos + 1; i < currentSize; i++) { buffer[i - 1] = buffer[i]; }
   currentSize--;
   return removed;
}

On average, n / 2 elements move
O(n)

Lecture 18 Clicker Question 1

Consider the removeLast operation of an ArrayList, implemented as

public Object removeLast() { return remove(size() - 1); }

Which of the following is true about this operaton?

It's O(n) since it calls remove which is O(n)
Its' O(1) since it does a constant amount of work, independent of the array size
It's O(n²) since both remove and size are O(n)
It's O(log n) because the size of the problem is cut in half in each step

Adding

Adding in the middle shifts elements with higher positions
On average, move n / 2 elements ⇒O(n)
Adding at the end is O(1)
Except when the array is completely full

Growing the Buffer

Allocate a new buffer of twice the size

Copy all the elements

private void growBufferIfNecessary()
{
   if (currentSize == buffer.length)
   {
      Object[] newBuffer = new Object[2 * buffer.length]; 
      for (int i = 0; i < buffer.length; i++) { newBuffer[i] = buffer[i]; }
      buffer = newBuffer; 
   }
}

Moves n elements ⇒ O(n)

Cost of n Additions

Start with array of size 10
Keep calling add (i.e. addLast)
First ten calls cost $1
Call 11: Oops, gotta pay $10
Then, next ten calls cost $1
Call 21: Oops, gotta pay $20
Then, next 20 calls cost $1
Call 41 costs $40 + $1
...

Amortized Cost

Charge $3 for each call to add
If it was a $1 call, put $2 in the piggy bank
First ten calls: Actual cost = 10 × $1 + $20 in the bank
Call 11: Take $10 from the bank to pay for the growing
Next ten calls: Actual cost = 10 × $1 + $20 in the bank
Call 21: Take $20 from the bank to pay for the growing
Next 20 calls: Actual cost = 20 × $1 + $40 in the bank
Call 41: Take $40 from the bank to pay for the growing
Amortized cost per call: $3
O(1)+

Comparing Linked Lists and Array Lists


	Array List	Doubly Linked List	Singly Linked List
Add at end	O(1)+	O(1)	O(1)
Remove at end	O(1)+	O(1)	O(n)
Add at head	O(n)	O(1)	O(1)
Remove at head	O(n)	O(1)	O(1)
Add in middle^*	O(n)	O(1)	O(1)
Remove in middle^*	O(n)	O(1)	O(1)

^*Provided you are already there (with an integer index or iterator)

Lecture 18 Clicker Question 2

You want to add a zero directly in the middle of a sequence of integers (or replace the middle element with a zero if the sequence has odd length). For example,

1 2 3 4 5 6 → 1 2 3 0 4 5 6

1 2 3 4 5 6 7 →1 2 3 0 5 6 7

Which data structure should you use for maximum efficiency

An array list
A doubly linked list
Either an array list or a linked list—it does not matter
A set