Arreglo S

Basic Data Structures:
Dynamic Arrays and

Amortized Analysis
Neil Rhodes
Department of Computer Science and Engineering
University of California, San Diego
Data Structures
Data Structures and Algorithms
Outline
1 Dynamic Arrays
2 Amortized Analysis—Aggregate Method
3 Amortized Analysis—Banker’s Method
4 Amortized Analysis—Physicist’s Method

Problem: static arrays are static!
int my_array[100];
Problem: static arrays are static!
int my_array[100];
Semi-solution: dynamically-allocated arrays:
int *my_array = new int[size];

Problem: might not know max size when
allocating an array
allocating an array
All problems in computer science
can be solved by another level of
indirection.
allocating an array
All problems in computer science
can be solved by another level of
indirection.
Solution: dynamic arrays (also known as
resizable arrays)
Idea: store a pointer to a dynamically
allocated array, and replace it with a
newly-allocated array as needed.
Definition
Dynamic Array:
Abstract data type with the following
operations (at a minimum):
*
must be constant time
Definition
Dynamic Array:
Get(i): returns element at location i *
*
Definition
Dynamic Array:
Set(i, val ): Sets element i to val *
*
Definition
Dynamic Array:
PushBack(val ): Adds val to the end
*
Definition
Dynamic Array:
Remove(i): Removes element at
location i
*
Definition
Dynamic Array:
Remove(i): Removes element at
location i
Size(): the number of elements
*
Implementation
Store:
arr: dynamically-allocated array
capacity: size of the
dynamically-allocated array
size: number of elements currently in
the array
Dynamic Array Resizing
arr size: 0 capacity: 2
PushBack(a)
PushBack(a)

a
PushBack(a)

a
PushBack(a)

a
PushBack(b)

a b
PushBack(b)

a b
PushBack(a)

a b
PushBack(c)

a b
PushBack(c)

a b
a
PushBack(c)

a b
a b
PushBack(c)

a b
a b
PushBack(c)
a b
PushBack(c)
a b c
PushBack(c)
a b c
PushBack(a)
a b c
PushBack(d)
a b c d
PushBack(d)
a b c d
PushBack(a)
a b c d
PushBack(e)
a b c d
PushBack(e)

a
a b c d
PushBack(e)

a b
a b c d
PushBack(e)

a b c
a b c d
PushBack(e)

a b c d
a b c d
PushBack(e)

a b c d
a b c d
PushBack(e)

a b c d
PushBack(e)

a b c d e
PushBack(e)
Get(i)
if i < 0 or i ≥ size:
ERROR: index out of range
return arr [i]
Set(i, val )
arr [i] = val
PushBack(val )
if size = capacity :
allocate new _arr [2 × capacity ]
for i from 0 to size − 1:
new _arr [i] ← arr [i]
free arr
arr ← new _arr ; capacity ← 2 × capacity
arr [size] ← val
size ← size + 1
Remove(i)
for j from i to size − 2:
arr [j] ← arr [j + 1]
size ← size − 1
Size()
return size
Common Implementations
C++: vector
Java: ArrayList
Python: list (the only kind of array)
Runtimes
Get(i) O(1)
Runtimes
Get(i) O(1)
Set(i, val ) O(1)
Runtimes
Get(i) O(1)
Set(i, val ) O(1)
PushBack(val ) O(n)
Runtimes
Get(i) O(1)
Set(i, val ) O(1)
PushBack(val ) O(n)
Remove(i) O(n)
Runtimes
Get(i) O(1)
Set(i, val ) O(1)
PushBack(val ) O(n)
Remove(i) O(n)
Size() O(1)
Summary
Unlike static arrays, dynamic arrays can

be resized.
Summary

be resized.
Appending a new element to a dynamic
array is often constant time, but can
take O(n).
Summary

be resized.
take O(n).
Some space is wasted
Summary

be resized.
take O(n).
Some space is wasted
Summary

be resized.
take O(n).
Some space is wasted—at most half.
Outline
1 Dynamic Arrays

Sometimes, looking at the individual
worst-case may be too severe. We may want
to know the total worst-case cost for a
sequence of operations.
Dynamic Array
We only resize every so often.
Many O(1) operations are followed by an
O(n) operations.
What is the total cost of inserting many
elements?
Definition
Amortized cost: Given a sequence of n
operations, the amortized cost is:
Cost(n operations)
n
Aggregate Method
Dynamic array: n calls to PushBack
Aggregate Method
Let ci = cost of i’th insertion.
Aggregate Method
{︃
ci = 1 +
Aggregate Method
{︃
i − 1 if i − 1 is a power of 2
ci = 1 +
Aggregate Method
{︃
ci = 1 +
0 otherwise
Aggregate Method
{︃
ci = 1 +
0 otherwise
∑︀n
i=1 ci
n
Aggregate Method
{︃
ci = 1 +
0 otherwise
∑︀⌊log2(n−1)⌋
2j
∑︀n
i=1 ci
n+ j=1
=
n n
Aggregate Method
{︃
ci = 1 +
0 otherwise
∑︀⌊log2(n−1)⌋
2j
∑︀n
i=1 ci
n+ j=1 O(n)
= =
n n n
Aggregate Method
{︃
ci = 1 +
0 otherwise
∑︀⌊log2(n−1)⌋
2j
∑︀n
i=1 ci
n+ j=1 O(n)
= = = O(1)
n n n
Outline
1 Dynamic Arrays

Banker’s Method
Charge extra for each cheap operation.

Banker’s Method

Save the extra charge as tokens in your
data structure (conceptually).
Banker’s Method

Use the tokens to pay for expensive
operations.
Banker’s Method

Use the tokens to pay for expensive
operations.
Like an amortizing loan.
Banker’s Method
Banker’s Method
Charge 3 for each insertion: 1 token is the

raw cost for insertion.
Banker’s Method

Resize needed: To pay for moving the
elements, use the token that’s present
on each element that needs to move.
Banker’s Method

elements, use the token that’s present
on each element that needs to move.
Place one token on the newly-inserted
element, and one token capacity
2 elements
prior.
PushBack(a)
PushBack(a)
PushBack(a)
PushBack(a)

a
PushBack(a)

a
PushBack(a)

a
PushBack(a)

a
PushBack(b)

a
PushBack(b)

a
a
PushBack(b)

a
a
PushBack(b)
PushBack(b)
a b
PushBack(b)
a b
PushBack(b)
a b
PushBack(b)
a b
PushBack(a)
a b
PushBack(c)
a b
PushBack(c)

a
a b
PushBack(c)

a b
a b
PushBack(c)

a b
a b
PushBack(c)

a b
PushBack(c)

a b c
PushBack(c)

a b c
PushBack(c)

a b c
PushBack(c)

a b c
PushBack(a)

a b c
PushBack(d)

a b c d
PushBack(d)

a b c d
PushBack(d)

a b c d
PushBack(d)

a b c d
PushBack(a)

a b c d
PushBack(e)

a b c d
PushBack(e)

a b c d
a
PushBack(e)

a b c d
a b
PushBack(e)

a b c d
a b c
PushBack(e)

a b c d
a b c d
PushBack(e)

a b c d
a b c d
PushBack(e)
a b c d
PushBack(e)
a b c d e
PushBack(e)
a b c d e
PushBack(e)
a b c d e
PushBack(e)
a b c d e
a b c d e
O(1) amortized cost for each PushBack

Banker’s Method
Charge 3 for each insertion. 1 coin is the raw
cost for insertion.
elements, use the coin that’s present on
each element that needs to move.
Place one coin on the newly-inserted
element, and one coin capacity
2 elements
prior.
Outline
1 Dynamic Arrays

Physicist’s Method
Define a potential function, Φ which
maps states of the data structure to
integers:
integers:
Φ(h0 ) = 0
integers:
Φ(h0 ) = 0
Φ(ht ) ≥ 0
integers:
Φ(h0 ) = 0
Φ(ht ) ≥ 0
amortized cost for operation t:
ct + Φ(ht ) − Φ(ht−1)
integers:
Φ(h0 ) = 0
Φ(ht ) ≥ 0
ct + Φ(ht ) − Φ(ht−1)
Choose Φ so that:
integers:
Φ(h0 ) = 0
Φ(ht ) ≥ 0
ct + Φ(ht ) − Φ(ht−1)
Choose Φ so that:
if ct is small, the potential increases
integers:
Φ(h0 ) = 0
Φ(ht ) ≥ 0
ct + Φ(ht ) − Φ(ht−1)
Choose Φ so that:
if ct is small, the potential increases
if ct is large, the potential decreases by
the same scale
∑︀n
The cost of n operations is: i=1 ci
The cost of n operations is: ni=1 ci
∑︀
The sum of the amortized costs is:

n
∑︁
(ci + Φ(hi ) − Φ(hi−1))
i=1
∑︀

n
∑︁
(ci + Φ(hi ) − Φ(hi−1))
i=1
=c1 + Φ(h1) − Φ(h0)+
c2 + Φ(h2) − Φ(h1) · · · +
cn + Φ(hn ) − Φ(hn−1)
∑︀

n
∑︁
(ci + Φ(hi ) − Φ(hi−1))
i=1
=c1 + Φ(h1) − Φ(h0)+
c2 + Φ(h2) − Φ(h1) · · · +
cn + Φ(hn ) − Φ(hn−1)
n
∑︁
=Φ(hn ) − Φ(h0) + ci
i=1
∑︀

n
∑︁
(ci + Φ(hi ) − Φ(hi−1))
i=1
=c1 + Φ(h1) − Φ(h0)+
c2 + Φ(h2) − Φ(h1) · · · +
cn + Φ(hn ) − Φ(hn−1)
n
∑︁ n
∑︁
=Φ(hn ) − Φ(h0) + ci ≥ ci
i=1 i=1

Let Φ(h) = 2 × size − capacity


Φ(h0) = 2 × 0 − 0 = 0

Φ(h0) = 2 × 0 − 0 = 0
Φ(hi ) = 2 × size − capacity > 0
(since size > capacity
2 )
Without resize when adding element i
Amortized cost of adding element i:



ci + Φ(hi ) − Φ(hi−1)

ci + Φ(hi ) − Φ(hi−1)
=1 + 2 × sizei − capi − (2 × sizei−1 − capi−1)

ci + Φ(hi ) − Φ(hi−1)
=1 + 2 × (sizei − sizei−1)

ci + Φ(hi ) − Φ(hi−1)
=1 + 2 × (sizei − sizei−1)
=3
With resize when adding element i
Let k = sizei−1 = capi−1
Then:
Φ(hi−1) = 2sizei−1 − capi−1 = 2k − k = k
Then:
Φ(hi ) = 2sizei − capi = 2(k + 1) − 2k = 2
Then:
Φ(hi ) = 2sizei − capi = 2(k + 1) − 2k = 2
Then:
Φ(hi ) = 2sizei − capi = 2(k + 1) − 2k = 2
ci + Φ(hi ) − Φ(hi−1)
Then:
Φ(hi ) = 2sizei − capi = 2(k + 1) − 2k = 2
ci + Φ(hi ) − Φ(hi−1)
=(sizei ) + 2 − k
Then:
Φ(hi ) = 2sizei − capi = 2(k + 1) − 2k = 2
ci + Φ(hi ) − Φ(hi−1)
=(sizei ) + 2 − k
=(k + 1) + 2 − k
Then:
Φ(hi ) = 2sizei − capi = 2(k + 1) − 2k = 2
ci + Φ(hi ) − Φ(hi−1)
=(sizei ) + 2 − k
=(k + 1) + 2 − k
=3
Alternatives to Doubling the Array
Size
We could use some different growth factor

(1.5, 2.5, etc.).
Could we use a constant amount?
Cannot Use Constant Amount
If we expand by 10 each time, then:
{︃
ci = 1 +
{︃
i − 1 if i − 1 is a multiple of 10
ci = 1 +
{︃
ci = 1 +
0 otherwise
{︃
ci = 1 +
0 otherwise
n
∑︀
ci
i=1
n
{︃
ci = 1 +
0 otherwise
n (n−1)/10
∑︀
n+ 10j
∑︀
ci
i=1 j=1
=
n n
{︃
ci = 1 +
0 otherwise
n (n−1)/10
∑︀ (n−1)/10
∑︀
n+ 10j n + 10 j
∑︀
ci
i=1 j=1 j=1
= =
n n n
{︃
ci = 1 +
0 otherwise
n (n−1)/10
∑︀ (n−1)/10
∑︀
n+ 10j n + 10 j
∑︀
ci
i=1 j=1 j=1
= =
n n n
n + 10O(n2)
=
n
{︃
ci = 1 +
0 otherwise
n (n−1)/10
∑︀ (n−1)/10
∑︀
n+ 10j n + 10 j
∑︀
ci
i=1 j=1 j=1
= =
n n n
n + 10O(n2) O(n2)
= =
n n
{︃
ci = 1 +
0 otherwise
n (n−1)/10
∑︀ (n−1)/10
∑︀
n+ 10j n + 10 j
∑︀
ci
i=1 j=1 j=1
= =
n n n
2 2
n + 10O(n ) O(n )
= = = O(n)
n n
Summary
Calculate amortized cost of an operation
in the context of a sequence of
operations.
Summary
operations.
Three ways to do analysis:
Summary
operations.
Aggregate method (brute-force sum)
Summary
operations.
Banker’s method (tokens)
Summary
operations.
Physicist’s method (potential function, Φ)
Summary
operations.
Physicist’s method (potential function, Φ)
Nothing changes in the code: runtime
analysis only.

Arreglo S

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Arreglo S

Загружено:

Авторское право:

Доступные форматы

Basic Data Structures:

Dynamic Arrays and

2 Amortized Analysis—Aggregate Method

3 Amortized Analysis—Banker’s Method

4 Amortized Analysis—Physicist’s Method

Semi-solution: dynamically-allocated arrays:

int *my_array = new int[size];

arr size: 0 capacity: 2

arr size: 0 capacity: 2

arr size: 1 capacity: 2

arr size: 1 capacity: 2

arr size: 1 capacity: 2

arr size: 2 capacity: 2

arr size: 2 capacity: 2

arr size: 2 capacity: 2

arr size: 2 capacity: 4

arr size: 2 capacity: 4

arr size: 2 capacity: 4

arr size: 2 capacity: 4

arr size: 2 capacity: 4

arr size: 3 capacity: 4

arr size: 3 capacity: 4

arr size: 3 capacity: 4

arr size: 4 capacity: 4

arr size: 4 capacity: 4

arr size: 4 capacity: 4

arr size: 4 capacity: 8

arr size: 4 capacity: 8

arr size: 4 capacity: 8

arr size: 4 capacity: 8

arr size: 4 capacity: 8

arr size: 4 capacity: 8

arr size: 4 capacity: 8

arr size: 5 capacity: 8

Unlike static arrays, dynamic arrays can

Unlike static arrays, dynamic arrays can

Unlike static arrays, dynamic arrays can

Unlike static arrays, dynamic arrays can

Unlike static arrays, dynamic arrays can

2 Amortized Analysis—Aggregate Method

3 Amortized Analysis—Banker’s Method

4 Amortized Analysis—Physicist’s Method

2 Amortized Analysis—Aggregate Method

3 Amortized Analysis—Banker’s Method

4 Amortized Analysis—Physicist’s Method

Charge extra for each cheap operation.

Charge extra for each cheap operation.

Charge extra for each cheap operation.

Charge extra for each cheap operation.

Charge 3 for each insertion: 1 token is the

Charge 3 for each insertion: 1 token is the

Charge 3 for each insertion: 1 token is the

arr size: 0 capacity: 0

arr size: 0 capacity: 0

arr size: 0 capacity: 1

arr size: 0 capacity: 1

arr size: 1 capacity: 1

arr size: 1 capacity: 1

arr size: 1 capacity: 1

arr size: 1 capacity: 1

arr size: 1 capacity: 2

arr size: 1 capacity: 2