IT2153/IT2352/IT2553/IT2653/IT2852

Data Structures & Algorithms

Topic 07: Array-based Sequences
version 1.0

(Content adapted from:

• Data Structures & Algorithms in Python. Michael T. Goodrich, Roberto
Tamassia & Michael H. Goldwasser, Wiley, 1st Edition, 2013.)

Topic 07: Array-based Sequences AY2022/23 S1

 Python Sequence Classes
 Python has built-in types, list, tuple, and str.
 Each of these sequence types supports indexing to
access an individual element of a sequence, using a
syntax such as A[i]
 Each of these types uses an array to represent the
sequence.
 An array is a set of memory locations that can be
addressed using consecutive indices, which, in Python,
start with index 0.

A
0 1 2 i n
2
Topic 07: Array-based Sequences AY2022/23 S1
 Arrays of Characters or
Object References
 An array can store primitive elements, such
as characters, giving us a compact array.

 An array can also store references to objects.

3
Topic 07: Array-based Sequences AY2022/23 S1
 Compact Arrays
 Primary support for compact arrays is in a
module named array.
 That module defines a class, also named array,
providing compact storage for arrays of primitive
data types.
 The constructor for the array class requires a
type code as a first parameter, which is a
character that designates the type of data
that will be stored in the array.

4
Topic 07: Array-based Sequences AY2022/23 S1
 Type Codes in the array Class
 Python’s array class has the following
type codes:

5
Topic 07: Array-based Sequences AY2022/23 S1
 Insertion
 In an operation add(i, o), we need to make room
for the new element by shifting forward the n − i
elements A[i], …, A[n − 1]
 In the worst case (i = 0), this takes O(n) time

A
0 1 2 i n
A
0 1 2 i n
A o
0 1 2 i n
6
Topic 07: Array-based Sequences AY2022/23 S1
 Element Removal
 In an operation remove(i), we need to fill the hole left by
the removed element by shifting backward the n − i − 1
elements A[i + 1], …, A[n − 1]
 In the worst case (i = 0), this takes O(n) time

A o
0 1 2 i n
A
0 1 2 i n
A
0 1 2 i n
7
Topic 07: Array-based Sequences AY2022/23 S1
 Performance
 In an array-based implementation of a
dynamic list:
 The space used by the data structure is O(n)
 Indexing the element at I takes O(1) time
 add and remove run in O(n) time in worst case
 In an add operation, when the array is full,
instead of throwing an exception, we can
replace the array with a larger one…

8
Topic 07: Array-based Sequences AY2022/23 S1
 Growable Array-based Array List
 In an add(o) operation
(without an index), we could Algorithm add(o)
if t = S.length − 1 then
always add at the end
A ← new array of
 When the array is full, we size …
replace the array with a for i ← 0 to n−1 do
larger one A[i] ← S[i]
 How large should the new S←A
array be? n←n+1
 Incremental strategy: increase
S[n−1] ← o
the size by a constant c
 Doubling strategy: double the
size
9
Topic 07: Array-based Sequences AY2022/23 S1
 Comparison of the Strategies
 We compare the incremental strategy and
the doubling strategy by analyzing the total
time T(n) needed to perform a series of n
add(o) operations
 We assume that we start with an empty
stack represented by an array of size 1
 We call amortized time of an add operation
the average time taken by an add over the
series of operations, i.e., T(n)/n

10
Topic 07: Array-based Sequences AY2022/23 S1
 Incremental Strategy Analysis
 We replace the array k = n/c times
 The total time T(n) of a series of n add
operations is proportional to
n + c + 2c + 3c + 4c + … + kc =
n + c(1 + 2 + 3 + … + k) =
n + ck(k + 1)/2
 Since c is a constant, T(n) is O(n + k2), i.e.,
O(n2)
 The amortized time of an add operation is O(n)

11
Topic 07: Array-based Sequences AY2022/23 S1
 Doubling Strategy Analysis
 We replace the array k = log2 n
times
geometric series
 The total time T(n) of a series of n
add operations is proportional to 2
n + 1 + 2 + 4 + 8 + …+ 2k = 4
1 1
n+2 k + 1 −1 =
3n − 1
8
 T(n) is O(n)
 The amortized time of an add
operation is O(1)
12
Topic 07: Array-based Sequences AY2022/23 S1
 Python Implementation

13
Topic 07: Array-based Sequences AY2022/23 S1