CSE 12

Fundamental Data Structures: The Array and

Linked Structures

Implementations of the List ADT

Properties of array and linked implementations
Separate and inner node classes
Singly and doubly linked lists

05

Introduction
Any interface specification can be correctly
implemented in many ways
However, different correct implementations may have
different performance characteristics
It is important to know these characteristics, as they
affect the performance of the resulting software

Collection ADT's

An ADT specifies a range of values that instances of

the type can have, and operations on those values

A collection ADT can use various data structures to

implement its values

The data structure a collection ADT uses internally is

sometimes called its backing store

For the List ADT, the backing store is typically chosen

to be either an array, or a linked list

Array Characteristics
An array is a homogeneous data structure: all elements are
of the same type

The elements of an array are in adjacent memory locations

Because each cell has the same size, and the cells are
adjacent in memory, it is possible to quickly calculate the
address of any array cell, given the address of the first cell
so accessing any array cell is constant time: just
one multiplication, one addition, and one memory
access
an array is a random (direct) access structure

Linked Structure Characteristics

Nodes in a linked structure are allocated and deallocated
dynamically, as needed

The nodes of a linked structure are created at different

times, and are probably not adjacent in memory
Even if the address of the first node in a linked structure is
known, it is impossible to directly calculate the address of
any other node; instead each node stores the address of the
next node in the structure
so a node access requires visiting all previous
nodes in the structure in sequence
a linked structure is a sequential access structure

Array Versus Linked Structures

Implementing Linked Lists

In a singly linked list, each node X contains:

a pointer to the node immediately after X in the list; or

null, or pointer to a dummy node, if X is the last node
in the list

the data in X (or a pointer to data)

In a doubly linked list, each node X contains:

a pointer to the node immediately after X in the list; or

null, or pointer to a dummy node, if X is the last node
in the list

a pointer to the node immediately before X in the list;

or null, or pointer to a dummy node, if X is the first
node in the list

the data in X (or a pointer to data)

Implementing Linked Lists

Taking an object oriented approach, you will define (at
least) two classes:
A node class
instances of this class will be nodes in the list
A list class
an instance of this class will contain (one or more
pointers to) instances of the node class

For each, consider the properties and behavior required

We will first show an example of a separate node class,
and later see how to define an inner node class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

SLNode<E>
/**
*
The structure of a node in a singly linked list
*/
public class SLNode<E> {
private E
data;
// the data field
private SLNode<E> next;
// link to successor

The self-referential
(recursive) part of
the definition

/**
* Create an empty <tt>SLNode</tt> object.
*/
public SLNode() {
this.data = null;
this.next = null;
}

/**
* Create an <tt>SLNode</tt> that stores <tt>theElement</tt> and
* whose successor is <tt>theSuccessor</tt>.
* @param theElement
the element to store in this node
* @param theSuccessor this nodes successor
*/
public SLNode( E theElement, SLNode<E> theSuccessor ) {
this.data = theElement;
this.next = theSuccessor;
}

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

SLNode<E>
/**
*
Successor accessor
*/
public SLNode<E> getSuccessor() {
return this.next;
}
/**
* Successor mutator
*/
public void setSuccessor(SLNode<E> n) {
this.next = n;
}
/**
*
Element accessor
*/
public E getData() {
return this.data;
}
/**
* Element mutator
*/
public void setData(E e) {
this.data = e;
}

SLNode instance
variables are private; so
we need to define public
accessors and mutators

SLNode construction
next
data

node2

SLNode<Integer> node2 = new SLNode<Integer>();

node2
node1

i1

next
data

next
data
15

Integer i1 = new Integer(15);

SLNode<Integer> node1 = new SLNode<Integer>(i1,node2);

Accessing the successor of a SLNode

node2
node1

i1

next
data

next
data
15

temp

SLNode<Integer> temp = node1.getSuccessor();

A Singly-linked List using SLNode

public class SinglyLinkedList<E> implements java.util.List<E>{
private SLNode<E> head; // used in options 1,2,3
private SLNode<E> tail; // used only in option 2
private int size;
// number of data elements in the list

One important issue: how to represent an empty list?

Need to be clear about this! It has implications for
correctly coding several of the List operations
We will consider some implementation options:
1. head pointer points directly to first node, or null if
none; no tail pointer
2. head, tail always point to 'dummy' nodes
3. head always points to 'dummy' node; no tail pointer

Option 1: direct head pointer

Create initially empty singly linked list

SinglyLinkedList<Integer> ls = new SinglyLinkedList<Integer>();

ls

head
size

Null head pointer means empty list, so size must be 0

Option 1: direct head pointer

After adding 4 data items to the list

ls

next
data

head
size

next
data

next
data

next
data

4
15

10

Using head directly as pointer to the

first node of the linked structure

40

77

Null next pointer

means end
of the list

Option 2: head and tail 'dummy'

nodes

Create initially empty singly linked list

SinglyLinkedList<Integer> ls = new SinglyLinkedList<Integer>();

ls

next
data

head
tail

next
data

size

Dummy head and tail nodes always exist.

Dummy head node next pointing to dummy tail node
means empty list, with size 0

Option 2: head and tail 'dummy'

nodes
After adding 4 data items to the list

ls

next
data

head
tail

next
data
15

next
data
size

next
data

next
data
10

next
data
40

77

Dummy head node next pointer points to first element of list

Last element of list next pointer points to same node as tail pointer

Inserting an element at the beginning

of the list, using option 1
pseudocode
void addAtHead(E theElement) {

1. Create the new SLNode

SLNode<E> newnode = new SLNode<E>(theElement, null);

2. Set the new nodes next field to point where head points
newnode.setSuccessor(head);

3. Set head to point to the new node

head = newnode;

4. Increment size by 1
size++;

Question: does this correctly handle cases both

of adding at the head of an empty list, and of a nonempty list?

Adding at the beginning of an empty list:

Step 1
head
size

newnode

next
data
77
element

1. Create the new SLNode

SLNode<E> newnode = new SLNode<E>( theElement, null );

Adding at the beginning of an empty list:

Step 2
head
size

newnode

next
data
77
element

2. Set the new nodes next field to point where head points
newnode.setSuccessor( head );

Adding at the beginning of an empty list:

Step 3
head
size

newnode

next
data
77
element

3. Set head to point to the new node, increment size

head = newnode;
size++;

Adding at the beginning of a nonempty

list: Step 1
next
data

head
size

next
data

next
data

next
data

4
15

newnode

10

40

77

next
data
77
element

1. Create the new SLNode

SLNode<E> newnode = new SLNode<E>( theElement, null );

Adding at the beginning of a nonempty

list: Step 2
next
data

head
size

next
data

next
data

4
15

newnode

next
data
10

40

77

next
data
77
element

2. Set the new nodes next field to point where head points
newnode.setSuccessor( head );

Adding at the beginning of a nonempty

list: Step 3
next
data

head
size

next
data

next
data

5
15

newnode

next
data
10

40

next
data
77
element

3. Set head to point to the new node, increment size

head = newnode;
size++;

77

Operations on a singly-linked list

Keep in mind the different options were considering
in implementing a singly linked list:
1. head pointer points directly to first node, or null if
none; no tail pointer
2. head, tail always point to 'dummy' nodes
3. head always points to 'dummy' node; no tail pointer

We have looked at adding a node at the beginning of a

linked list in the context of option 1
Next we will look at adding a node at an arbitrary index
in a linked list, using option 1

Inserting an element at an index in

the list (using option 1)
public void add(int index, E theElement) {

1. check index >=0 && index <= size

if(index < 0 || index > size) throw new IOBException();

2. advance cursor to point to node just before insertion point

SLNode<E> cursor = head;
while(--index > 0) cursor = cursor.getSuccessor();

4. Create new node

SLNode<E> newnode = new SLNode<E>(theElement, null);

5. Set the new nodes next to be same as cursor's next

newnode.setSuccessor(cursor.getSuccessor());

6. Set cursor's next to point to the new node

cursor.setSuccessor(newnode);

7. Increment size by 1
size++;
}

Adding at index 2 in a list: Step 4

cursor
next
data

head
size

next
data

next
data

next
data

4
15

newnode

10

40

77

next
data
77
element

4. Create the new SLNode

SLNode<E> newnode = new SLNode<E>( theElement, null );

Adding at index 2 in a list: Step 5

cursor
next
data

head
size

next
data

next
data

4
15

newnode

next
data
10

40

77

next
data
77
element

5. Set newnode's next to be same as cursor's next

newnode.setSuccessor(cursor.getSuccessor());

Adding at index 2 in a list: Step 6

cursor
next
data

head
size

next
data

next
data

next
data

5
15

10

newnode

40

77

next
data
77
element

6. Set cursor's next to point to the new node, increment size

cursor.setSuccessor(newnode);
size++;

Adding at an index: cases to test

Does that add method work in all cases:

index == 0 ?

index == size ?

index == 0 when list is empty (so index==size

also)?

0 < index < size ?

If not, how can you fix it so it does work?
Would option 2 (using dummy head and tail nodes)
make the implementation easier?

Inserting an element at the beginning

of the list (using option 2)
void addAtHead(E theElement) {

1. Create the new SLNode

SLNode<E> newnode = new SLNode<E>(theElement, null);

2. Set the new nodes next to be same as dummy head node's next
newnode.setSuccessor(head.getSuccessor());

3. Set dummy head's next to point to the new node

head.setSuccessor(newnode);

4. Increment size by 1
size++;

Question: does this correctly handle the special

case of adding at the head of an empty list?

Deleting a node at an index:

pseudocode
1 public E remove ( int p ) {

1. Verify that p is within the linked list bounds

2. Move cursor to node with index p 1
3. Let target = cursor's successor: the node to remove
6

SLNode<E> target = cursor.getSuccessor();

4. Save the targets data, to return it

7

E element = target.getData();

5. Make cursor's next point to target's successor node.

(This removes target node from the list)
8

cursor.setSuccessor( target.getSuccessor() );

6. Decrement size
9

size--;

7. Return the element stored in the target node

10
11 }

return element;

Removing at index 2 in a list: Step 3

target
cursor
next
data

head
size

next
data

next
data

next
data

4
15

10

40

77

3. Let target = cursor's successor: the node to remove

SLNode<E> target = cursor.getSuccessor();

Removing at index 2 in a list: Step 5

target

cursor
next
data

head
size

next
data

next
data

next
data

3
15

10

40

77

5. Make cursor's next point to target's successor node.

cursor.setSuccessor( target.getSuccessor() );
size--;

Deleting a Node: Cleanup

Splicing around the node to be deleted, as shown,

removes it from the linked list

a traversal from the head of the list will no longer

encounter the node at all
Furthermore, consider the pointer variable target

It is a local variable in the remove method

It will be destroyed when the method returns

Then the program has no 'live' pointers to the

deleted node, and Java's garbage collector can
reclaim it
Nothing more needs to be done...!

Using an inner class for the node class

The previous example used a separate, top-level public

class SLNode<E> to define a singly-linked node type,
with accessor and mutator methods to manipulate the
node

Another approach is to use a private static inner class

to define a node, and access instance variables of
node objects directly, instead of using accessor/mutator
methods
This is a good example of making implementation
details (in this case, the entire definition of the
lists node class) private!

Using an inner class for the node class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.*;
/**
*
Outer class: List<E>
*/
public class SinglyLinkedList<E> implements java.util.List<E> {
private Node<E> head;
// pointer to first element (not dummy)
private int size;
// number of nodes in this List
/**
* private static inner class: Node<T>
*/
private static class Node<T> {
private T data; // the data field
private Node<T> next; // link to successor
private Node(T data) { // inner class constructor
this.data = data;
}
}
public SinglyLinkedList () {
// outer class constructor
head = null; // null head means empty list
size = 0;
}

Inserting an element at the

beginning, using Option 1 with an
inner node class
void addAtHead(E theElement) {

1. Create the new Node

Node<E> newnode = new Node<E>(theElement);

2. Set the new nodes next field to point where head is pointing
newnode.next = head;

3. Set head to point to the new node

head = newnode;

4. Increment size by 1
size++;

Question: does this correctly handle the special

case of adding to an empty list?

Doubly-Linked Lists
The singly-linked list is unidirectional
At the expense of an additional link (and the
consequent code complexity) we can have a
bidirectional list

We need to add a
second link
attribute to the
node definition

Circular Doubly-Linked Lists

We considered a singly-linked list implementation
using dummy head and tail nodes
Because of the bidirectional nature of a doubly-linked
list, it is possible to use just one dummy node, which
is both a head and a tail node!
The first node in the list has its predecessor pointer
pointing to the dummy node, and the last node in the
list has its successor pointer pointing to the dummy
node
Thus the list is circular, in that following successor
(or predecessor) pointers will eventually get you back
to where you started

A Circular Doubly-Linked List

This circular doubly linked list has size 3
From first to last, the data elements are: A, B, C

Time Complexity for Array Operations

Time Complexity for the Array Backing Store (n = # of occupied cells)
Operation

Cost

read at an index, worst case

(1)

add/remove (at the end of the array)

(1)

add/remove (in the interior of the array)

(n)

resize

(length of new array)

find by index

(1)

find by target

(n)

Time Complexity for Linked Operations

Time Complexity for the Linked List Backing Store
Operation

Cost
Singly Linked

Doubly Linked

read at an index, worst case

(n)

(n)

add/remove (at the head)

(1)

(1)

add/remove (at the tail)

(n)

(1)

add/remove (in the interior of the list)

(n)

(n)

resize

N/A

N/A

find by index

(n)

(n)

find by target

(n)

(n)

Next time

Algorithm analysis vs. measurement

Timing an algorithm
Average and standard deviation
Improving measurement accuracy

Reading: Gray, Ch 2