COMMONWEALTH OF AUSTRALIA

Copyright Regulations 1969

WARNING

This material has been reproduced and communicated to you by or on behalf

of the University of Sydney pursuant to Part VB of the Copyright Act 1968
(the Act). The material in this communication may be subject to copyright under
the Act. Any further copying or communication of this material by you may be
the subject of copyright protection under the Act.

Do not remove this notice.

The University of Sydney Page 1

Data structures and Algorithms
Lecture 2: Lists
[GT 2.1-2.2]
Mentimeter: 3188 3244

A/Prof Julian Mestre

School of Computer Science

The University of Sydney Page 2

 Abstract Data Types (ADT)

Type defined in terms of its data items and

associated operations, not its implementation.

ADTs are supported by many languages, including

Python.

The University of Sydney Page 3

 Abstract Data Types (ADT)

Type defined in terms of its data items and

associated operations, not its implementation.

Simple example: Driving a car

interface

implementation

The University of Sydney Page 4

 Benefits of ADT approach

– Code is easier to understand if different issues are separated

into different places.

– Client can be considered at a higher, more abstract, level.

– Many different systems can use the same library, so only code
tricky manipulations once, rather than in every client system.

– There can be choices of implementations with different

performance tradeoffs, and the client doesn’t need to be
rewritten extensively to change which implementation it uses.

The University of Sydney Page 5

 Example: Reservation system

– We have a theatre with

500 named seats, e.g., “N31”

– What kind of data should be stored?

– Seats names
– Seats reserved or available.
– If reserved, name of the person who reserved the seat.

– Operations needed?

The University of Sydney Page 6

 Example: Reservation system

– Operations needed?

– capacity_available() : number of available seats (integer)

– capacity_sold() : number of seats with reservations
– customer(x) : name of customer who bought seat x
– release(x) : make seat x available (ticket returned)
– reserve(x, y) : customer y buys ticket for seat x
– add(x) : install new seat whose id is x
– get_available(): access available seats

The University of Sydney Page 7

 ADT challenges

– Specify how to deal with the boundary cases

– what to do if reserve(x, y) is invoked when x is
already occupied?
– what other cases can you think of?

– Do we need a new ADT? Could we use an existing

one, perhaps by renaming the operations and
tweaking the error-handling?
– “Adapter” design pattern (see SOFT2201)
– Could this example be mapped to an ADT you
already know?

The University of Sydney Page 8

 Abstract data types and Data structures

An abstract data type (ADT) is a specification of the desired

behaviour from the point of view of the user of the data.

A data structure is a concrete representation of data, and this is

from the point of view of an implementer, not a user.

Distinction is subtle but similar to the difference between a

computational problems and an algorithm.

The University of Sydney Page 9

 ADT in programming (Python)

– ADT is given as an abstract base class (abc)

– An abc declares methods (with their names and signatures)

usually without providing code and we can’t construct instances

– A data structure implementation is a class that inherits from the

abc, provides code for all the required methods (and perhaps
others) and has a constructor

– Client code can have variables that are instances of the data
structure class and can call methods on these variables

The University of Sydney Page 10

 Index-Based Lists (List ADT)

An index-based list (usually) supports the following operations:

size() (int) number of elements in the store

isEmpty() (boolean) whether or not the store is empty

get(i) return element at index i

set(i, e) replace element at index i with element e,
and return element that was replaced
add(i, e) insert element e at index i existing elements with
index ³ i are shifted up
remove(i) remove and return the element at index i existing
elements with index ³ i are shifted down
The University of Sydney Page 11
 Example

A sequence of List operations:

Method Returned value List content

add(0,A) - [A]
add(0,B) - [B, A]
get(1) A [B, A]
set(2,C) “error” [B, A]
add(2,C) - [B, A, C]
add(4,D) “error” [B, A, C]
remove(1) A [B, C]
add(1,D) - [B, D, C]
add(1,E) - [B, E, D, C]
get(4) “error” [B, E, D, C]
add(4,F) - [B, E, D, C, F]
set(2,G) D [B, E, G, C, F]
The University of Sydney Page 12
 Array-based Lists

An option for implementing the list ADT is to use an array A,

where A[i] stores (a reference to) the element with index i.
If array has size N then we can represent lists of size n ≤ N

A
0 1 2 i n N-1

ith
element

allocated memory
The University of Sydney Page 13
 Array-based Lists

How is an array stored?

Array

Memory

The University of Sydney Page 14

 Array-based Lists: get(i)

The get(i) and set(i, e) methods are easy to implement by

accessing A[i]
Must check that i is a legitimate index (0 ≤ i < n)
Both operations can be carried out in in constant time
(a.k.a. O(1) time), independent of the size of the array
A
0 1 2 i n N-1

ith
element

allocated memory
The University of Sydney Page 15
 Array-based Lists: set(i,e)

The get(i) and set(i, e) methods are easy to implement by

accessing A[i]
Must check that i is a legitimate index (0 ≤ i < n)

A
0 1 2 i n N-1

previous new
ith element ith element

allocated memory
The University of Sydney Page 16
 Pseudo-code for get

def get(i):
# input: index i
# output: ith element in list
if i < 0 or i ³ n then
return “index out of bound”
else
return A[i]

Time complexity of this operation is O(1) time, independent of the

size of the array (N) or the represented list (n)

The University of Sydney Page 17

 Pseudo-code for set

def set(i, e):

# input: index i and value e
# do: update ith element in list to e
if i < 0 or i ³ n then
return “index out of bound”
result ← A[i]
A[i] ← e
return result

Time complexity of operation is O(1) time, independent of the size

of the array (N) or the represented list (n)

The University of Sydney Page 18

 Array-based Lists: add(i,e)

In an operation add(i, e), we must make room for the new

element by shifting forward n - i elements A[i], …, A[n - 1]

Must check that there is space (n < N)

What is the most time consuming scenario?

A
0 1 2 i n

A
0 1 2 i n

A o
0 1 2 i n
The University of Sydney Page 19
 Pseudo-code for insertion

def add(i, e):

if n = N then
return “array is full”
if i < n then
for j in [n-1, n-2, … , i] do
A[j + 1] ← A[j]
A[i] ← e
n ← n + 1

Time complexity is O(n) in the worst case

The University of Sydney Page 20

 Array-based Lists: remove(i)

In an operation remove(i), we need to fill the hole left at position i

by shifting backward n - i - 1 elements A[i + 1], …, A[n - 1]

Must check that i is a legitimate index (0 ≤ i < n)

A
0 1 2 i n

A
0 1 2 i n

A
0 1 2 i n

The University of Sydney Page 21

 Pseudo-code for removal

def remove(i):
if i < 0 or i ³ n
return “index out of bound”
e ← A[i]
if i < n-1
for j in [i, i+1, … , n-2] do
A[j] ← A[j+1]
n ← n - 1
return e

Time complexity is O(n) in the worst case

The University of Sydney Page 22

 Summary of (static) array-based Lists

Limitations:
– can represent lists up to the capacity of the array (n vs N)

Space complexity:
– space used is O(N), whereas we would like it to be O(n)

Time complexity:
– both get and set take O(1) time
– both add and remove take O(n) time in the worst case

The University of Sydney Page 23

 Positional Lists object

ADT for a list where we store elements at “positions”

Position models the abstract notion of place where a single object

is stored within a container data structure.

Unlike index, this keeps referring to the same entry even after
insertion/deletion happens elsewhere in the collection.

Position offers just one method:

element() : return the element stored at the position instance

The University of Sydney Page 24

 Positional Lists - Operations

size() (int) number of elements in the store

isEmpty() (boolean) whether or not the store is empty

first() return position of first element (null if empty)

last() return position of last element (null if empty)
before(p) return position immediately before p (null if p is first)
after(p) return position immediately after p (null if p last)
insertBefore(p, e) insert e in front of the element at position p
insertAfter(p, e) insert e following the element at position p
remove(p) remove and return the element at position p

The University of Sydney Page 25

 Singly Linked List

– A concrete data structure

– A sequence of Nodes, each with a reference to the next node

– List captured by reference (head) to the first Node

head

A B C D

The University of Sydney Page 26

 Node implements Position

Each Node in a singly linked List stores

– its element, and
– a link to the next node.

x: Node
next

element

The University of Sydney Page 27

 Advice on working with linked structures

– Draw the diagram showing the state.

– Show a location where you place carefully each of the instance

variables (including references to nodes).

– Be careful to step through dotted accesses e.g. p.next.next

– Be careful about assignments to fields e.g.

p.next = q or p.next.next = r

∅
head
A B C D
The University of Sydney Page 28
 Linked Lists

How are linked lists stored?

Memory

The University of Sydney Page 29

 first()

first() : return position of first element (null if empty)

return?

∅
head
A B C D

The University of Sydney Page 30

 first()

first() : return position of first element (null if empty)

return head

∅
head
A B C D

Time complexity?

The University of Sydney Page 31

 insertFirst(e)

1. Instantiate a new node x

2. Set e as element of x
3. Set x.next to point to (old) head
4. Update list’s head to point to x

head

A B C D

The University of Sydney Page 32

 insertFirst(e)

1. Instantiate a new node x

2. Set e as element of x
3. Set x.next to point to (old) head
4. Update list’s head to point to x

head

x
∅

A B C D

The University of Sydney Page 33

 insertFirst(e)

1. Instantiate a new node x

2. Set e as element of x
3. Set x.next to point to (old) head
4. Update list’s head to point to x

head

x
∅

e A B C D

The University of Sydney Page 34

 insertFirst(e)

1. Instantiate a new node x

2. Set e as element of x
3. Set x.next to point to (old) head
4. Update list’s head to point to x

head

x
∅

e A B C D

The University of Sydney Page 35

 insertFirst(e)

1. Instantiate a new node x

2. Set e as element of x
3. Set x.next to point to (old) head
4. Update list’s head to point to x

What is the time complexity?

head

x
∅

e A B C D

The University of Sydney Page 36

 insertFirst(e)

1. Instantiate a new node x

2. Set e as element of x
3. Set x.next to point to (old) head
4. Update list’s head to point to x

What is the time complexity? O(1)

head

x
∅

e A B C D

The University of Sydney Page 37

 removeFirst()

1. Update head to point to next node

2. Delete the former first node

head

A B C D

The University of Sydney Page 38

 removeFirst()

1. Update head to point to next node

2. Delete the former first node

head

A B C D

The University of Sydney Page 39

 removeFirst()

1. Update head to point to next node

2. Delete the former first node

head

A B C D

The University of Sydney Page 40

 removeFirst()

1. Update head to point to next node

2. Delete the former first node

Time complexity?

head

B C D

The University of Sydney Page 41

 removeFirst()

1. Update head to point to next node

2. Delete the former first node

Time complexity? O(1)

head

B C D

The University of Sydney Page 42

 insertBefore(p,e)

insertBefore(p,e) : insert e in front of the element at position p

∅
head
A B C D

The University of Sydney Page 43

 insertBefore(p,e)

insertBefore(p,e) : insert e in front of the element at position p

x
p

∅
head
A B C D

The University of Sydney Page 44

 insertBefore(p,e)

insertBefore(p,e) : insert e in front of the element at position p

x
p

∅
head
A B C D

What’s the next step?

The University of Sydney Page 45

 insertBefore(p,e)

insertBefore(p,e) : insert e in front of the element at position p

x
p

∅
head
A B C D

What’s the next step? Find the predecessor of x. How?

The University of Sydney Page 46

 insertBefore(p,e)

To find the predecessor of p we need to follow the links from

the “head”. Time complexity?
x
p

∅
head
A B C D

The University of Sydney Page 47

 insertBefore(p,e)

To find the predecessor of p we need to follow the links from

the “head”. Time complexity: O(n)
x
p

∅
head
A B C D

The University of Sydney Page 48

 insertBefore(p,e)

There is no constant-time way to find the predecessor of a node in

a Singly Linked List.

∅
head
A B C D

The University of Sydney Page 49

 Another attempt

A very natural way to implement a positional list is with a doubly-

linked list, so that it is easy/quick to find the position before.

Each Node in a Doubly Linked List stores

– its element, and
– a link to the previous and next nodes.

prev next

element
The University of Sydney Page 50
 Doubly Linked Lists

A concrete data structure

– A sequence of Nodes, each with reference to prev and to next
– List captured by references to its Sentinel Nodes

nodes
header trailer

NULL NULL

The University of Sydney elements Page 51

 insertBefore(p,e) – step 1

A B C
Instantiate new Node x with element set to e.
Update x.previous to point to p.previous and x.next to point to p.

A B C

e
The University of Sydney Page 52
 insertBefore(p,e) – step 2

A B C

e
Update p.prev.next ¬ x and p.prev ¬ x

x p

A B e C
The University of Sydney Page 53
 insertBefore(p,e)

– Insert a new node with element e between p and its

predecessor.
p

A B C

A B x C

e
x p

A B e C
The University of Sydney Page 54
 Pseudo-code

def insert_before(pos, elem):

// insert elem before pos
// assuming it is a legal pos

new_node ← create a new node

new_node.element ← elem
new_node.prev ← pos.prev
new_node.next ← pos
pos.prev.next ← new_node
pos.prev ← new_node

return new_node

The University of Sydney Page 55

 remove(p)

– Remove a node, p, from a doubly-linked list.

p

A B C D

A B C p

A B C
The University of Sydney Page 56
 Pseudo-code

def remove(pos):
// remove pos from the list
// assuming it is a legal pos

pos.prev.next ← pos.next
pos.next.prev ← pos.prev

return pos.element

The University of Sydney Page 57

 Performance

A (doubly) linked list can perform all of the accessor and update
operations for a positional list in constant time.

Method Time
Space complexity is O(n)
first() O(1)
last() O(1)
Time complexity is O(1) for
before(p) O(1)
all operations
after(p) O(1)
insert_before(p, e) O(1)
insert_after(p, e) O(1)
remove(p) O(1)
size() O(1)
is_empty() O(1)

The University of Sydney Page 58

 Array or Linked List implementation?

Linked List
– good match to positional ADT
– efficient insertion and deletion
– simpler behaviour as collection grows
– modifications can be made as collection iterated over
– space not wasted by list not having maximum capacity

Arrays
– good match to index-based ADT
– caching makes traversal fast in practice
– no extra memory needed to store pointers
– allow random access (retrieve element by index)

The University of Sydney Page 59

 Iterators

Abstracts the process of stepping through a collection of elements

one at a time by extending the concept of position

Implemented by maintaining a cursor to the “current” element

Two notions of iterator:

– snapshot freezes the contents of the data structure
(unpredictable behaviour if we modify the collection)
– dynamic follows changes to the data structure
(behaviour changes predictably)

The University of Sydney Page 60

 Iterators in Python

iter(obj) returns an iterator of the object collection

To make a class iterable define the method __iter__(self)

The method __iter__() returns an object having a next() method

Calling next() returns the next object and advances the cursor or
raises StopIteration()

The University of Sydney Page 61

 Iterators in Python

for x in obj:
// process x

Is equivalent to:

it = x.__iter__()
try:
while True:
x = it.next()
// process x
except StopIteration:
pass

The University of Sydney Page 62

 Stacks and queues

These ADTs are restricted forms of List, where insertions and

removals happen only in particular locations:
– stacks follow last-in-first-out (LIFO)
– queues follows first-in-first-out (FIFO)

So why should we care about a less general ADT?

– operations names are part of computing culture
– numerous applications
– simpler/more efficient implementations than Lists

The University of Sydney Page 63

 Stack ADT

Main stack operations:

– push(e): inserts an element, e
– pop(): removes and returns the last inserted element

Auxiliary stack operations:

– top(): returns the last inserted element without
removing it
– size(): returns the number of elements stored
– isEmpty(): indicates whether no elements are stored

The University of Sydney Page 64

 Stack Example

operation returns stack

push(5) - [5]
push(3) - [5, 3]
size() 2 [5, 3]
pop() 3 [5]
isEmpty() False [5]
pop() 5 []
isEmpty() True []
push(7) - [7]
push(9) - [7, 9]
top() 9 [7, 9]
push(4) - [7, 9, 4]
pop() 4 [7, 9]

The University of Sydney Page 65

 Stack Applications

Direct applications
– Keep track of a history that allows undoing such as Web
browser history or undo sequence in a text editor
– Chain of method calls in a language supporting recursion
– Context-free grammars

Indirect applications
– Auxiliary data structure for algorithms
– Component of other data structures

The University of Sydney Page 66

 Method Stacks

The runtime environment keeps track

of the chain of active methods with a bar
def main()
stack, thus allowing recursion i = 5; PC = 1
foo(i); m=6
When a method is called, the system def foo(j)
pushes on the stack a frame containing k = j+1; foo
bar(k); PC = 2
– Local variables and return value
j=5
– Program counter def bar(m) k=6
…

When a method ends, we pop its main

frame and pass control to the method PC = 2
on top i=5

The University of Sydney Page 67

 Parentheses Matching

Each “(”, “{”, or “[” must be paired with a matching “)”, “}”, or “]”
– correct: ( )(( )){([( )])}
– correct: ((( )(( )){([( )])}))
– incorrect: )(( )){([( )])}
– incorrect: ({[ ])}
– incorrect: (

Scan input string from left to right:

– If we see an opening character, push it to a stack
– If we see a closing character, pop character on stack and
check that they match

The University of Sydney Page 68

 Stack implementation based on arrays

def size()
A simple way of implementing the return t + 1
Stack ADT uses an array:
– Array has capacity N def pop()
if isEmpty() then
– Add elements from left to right
return null
– A variable t keeps track of the else
index of the top element t ¬ t - 1
return S[t + 1]

…
S
0 1 2 t N-1

The University of Sydney Page 69

 Stack implementation based on arrays

– The array storing the def push(e)

stack elements may if t = N - 1 then
return “stack overflow”
become full
else
– A push operation will t ¬ t + 1
then either grow the S[t] ¬ e
array or signal a “stack
overflow” error.

…
S
0 1 2 t
The University of Sydney Page 70
 Stack implementation based on arrays

Performance
– The space used is O(N)
– Each operation runs in time O(1)

Qualifications
– Trying to push a new element into a full stack causes an
implementation-specific exception or
– Pushing an item on a full stack causes the underlying
array to double in size, which implies each operation
runs in O(1) amortized time (still O(n) worst-case).

The University of Sydney Page 71

 Queue ADT

Main queue operations:

– enqueue(e): inserts an element, e, at the end of the queue
– dequeue(): removes and returns element at the front of the queue

Auxiliary queue operations:

– first(): returns the element at the front without removing it
– size(): returns the number of elements stored
– isEmpty(): indicates whether no elements are stored

Boundary cases:
– Attempting the execution of dequeue or first on an empty queue signals
an error or returns null

The University of Sydney Page 72

 Queue Example
Operation Output Queue
enqueue(5) – (5)
enqueue(3) – (5, 3)
dequeue() 5 (3)
enqueue(7) – (3, 7)
dequeue() 3 (7)
first() 7 (7)
dequeue() 7 ()
dequeue() null ()
isEmpty() true ()
enqueue(9) – (9)
enqueue(7) – (9, 7)
size() 2 (9, 7)
enqueue(3) – (9, 7, 3)
enqueue(5) – (9, 7, 3, 5)
dequeue() 9 (7, 3, 5)
The University of Sydney Page 73
 Queue applications

Buffering packets in streams, e.g., video or audio

Direct applications
– Waiting lists, bureaucracy
– Access to shared resources (e.g., printer)
– Multiprogramming

Indirect applications
– Auxiliary data structure for algorithms
– Component of other data structures

The University of Sydney Page 74

 Queue application: Round Robin Schedulers

Implement a round robin scheduler using a queue Q by

repeatedly performing the following steps:
1. e ¬ Q.dequeue()
2. Service element e
3. Q.enqueue(e)

Queue

Dequeue Enqueue

Shared
Service
The University of Sydney Page 75
 Queue implementation based on arrays

Use an array of size N in a circular fashion

Two variables keep track of the front and size
start : index of the front element
end : index past the last element
size : number of stored elements
These are related as follows end = (start + size) mod N,
so we only need two, start and size

normal configuration
Q
0 1 2 start end N-1
wrapped-around configuration
Q
0 1 2 end start N-1
The University of Sydney Page 76
 How to get in a wrapped-around configuration

– Enqueue N elements
– Dequeue k < N elements
– Enqueue k’ < k elements

start
end

start
end

end start

The University of Sydney end start Page 77

 Queue Operations: Enqueue

Return an error if the def enqueue(e)

array is full. Alternatively, if size = N then
return “queue full”
we could grow the else
underlying array as end ¬ (start + size) mod N
dynamic arrays do Q[end] ¬ e
size ¬ size + 1

Q
0 1 2 start end N-1

Q
0 1 2 end start N-1

The University of Sydney Page 78

 Queue Operations: Dequeue

def dequeue()
Note that operation
if isEmpty() then
dequeue returns error if
the queue is empty return “queue empty”
else
e ¬ Q[start]
One could alternatively start ¬ (start + 1) mod N
return null size ¬ (size - 1)
return e

Q
0 1 2 start end N-1

Q
0 1 2 end start N-1
The University of Sydney Page 79
 Queue implementation based on arrays

Performance
– The space used is O(N)
– Each operation runs in time O(1)

The University of Sydney Page 80

 This week

Tutorial Sheet 1: Available on Ed

Quiz 1: Available on Canvas at the end of this lecture

The University of Sydney Page 81