CS 46B - Lecture 18

Pre-class reading

• Section 16.2

Object Diagrams

• Object has
  • Type (e.g. Node)
  • Fields (e.g. data, next)
• Each field has
  • Name
  • Contents
• Contents can be
  • value (number, string)
  • reference (arrow to another object)
• Use circled numbers ➊ ➋ ➌ for steps

Object Diagrams

Lecture 16 Paper Question 1

Look at my solution to Homework 10a.

Look at this test case.

Draw a diagram of what goes on in the call to names.reverseFirstN(2);.

Write your name and student ID on your sheet. When prompted, hand it to the front.

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?

1. It's O(n) since it calls remove which is O(n)
2. Its' O(1) since it does a constant amount of work, independent of the array size
3. It's O(n²) since both remove and size are O(n)
4. 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

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

Clicker Question

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

1. An array list
2. A doubly linked list
3. Either an array list or a linked list—it does not matter
4. A set

Implementing Stacks and Queues

• Stacks as linked lists
• Stacks as array lists
• Queues as linked lists
• Queues as circular arrays

Stacks as Linked Lists

• Sequence of nodes
• Singly linked list
• push adds a new node
• pop removes a node
• Both are O(1)

Clicker Question

Where should the nodes be added/removed for maximum efficiency?

1. push adds before first, pop removes last
2. push adds before first, pop removes first
3. push adds after last, pop removes last
4. push adds after last, pop removes first

Stacks as Array Lists

• Use buffer that can fill up
• Relocate buffer, doubling its size when it is full
• push adds element to buffer, increments size
• pop returns buffer element, decrements size
• Both are O(1)+

Clicker Question

Where should the elements be added/removed for maximum efficiency?

1. push adds before first, pop removes last
2. push adds before first, pop removes first
3. push adds after last, pop removes last
4. push adds after last, pop removes first

Queues as Linked Lists

• Sequence of nodes
• Singly linked list
• add adds a new node
• remove removes a node
• Both are O(1)

Clicker Question

Where should the nodes be added/removed for maximum efficiency?

1. add adds before first, remove removes last
2. add adds before first, remove removes first
3. add adds after last, remove removes last
4. add adds after last, remove removes first

Queues as Circular Arrays

• Use buffer that can fill up
• Index for head, tail
• Occupied area can “wrap around”
• add/remove are O(1)+

Clicker Question

Assume the buffer has size 10. What is its contents after these operations?

for (i = 1; i <= 8; i++) q.add(i);
for (i = 1; i <= 4; i++) q.remove();
for (i = 1; i <= 8; i++) q.add(i);
for (i = 1; i <= 4; i++) q.remove();

1. 1 2 3 4 5 6 7 8
2. 3 4 5 6 7 8 7 8 1 2
3. 3 4 5 6 7 8 0 0 1 2
4. Something else