Elementary Data

Structures
Stacks, Queues, & Lists
Amortized analysis
Trees
The Stack ADT (§2.1.1)
The Stack ADT stores
arbitrary objects
Insertions and deletions Auxiliary stack
follow the last-in first-out operations:
scheme  object top(): returns the
Think of a spring-loaded last inserted element
plate dispenser without removing it
Main stack operations:  integer size(): returns the
 push(object): inserts an number of elements
element stored
 object pop(): removes and  boolean isEmpty():
returns the last inserted indicates whether no
element elements are stored

Elementary Data Structures 2

Applications of Stacks
Direct applications
 Page-visited history in a Web browser
 Undo sequence in a text editor
 Chain of method calls in the Java Virtual
Machine or C++ runtime environment
Indirect applications
 Auxiliary data structure for algorithms
 Component of other data structures

Elementary Data Structures 3

Array-based Stack (§2.1.1)
Algorithm pop():
if isEmpty() then
A simple way of throw EmptyStackException
implementing the else
Stack ADT uses an tt1
array
return S[t + 1]
We add elements
from left to right Algorithm push(o)
A variable t keeps if t = S.length  1 then
track of the index of throw FullStackException
the top element else
(size is t+1) tt+1
S[t]  o
…
S
0 1 2 t
Elementary Data Structures 4
Growable Array-based
Stack (§1.5)
In a push operation, when
the array is full, instead of
throwing an exception, we Algorithm push(o)
can replace the array with if t = S.length  1 then
a larger one A  new array of
size …
How large should the new for i  0 to t do
array be? A[i]  S[i]
 incremental strategy: SA
increase the size by a tt+1
constant c
S[t]  o
 doubling strategy: double
the size
Elementary Data Structures 5
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
push operations
We assume that we start with an empty
stack represented by an array of size 1
We call amortized time of a push operation
the average time taken by a push over the
series of operations, i.e., T(n)/n
Elementary Data Structures 6
Analysis of the
Incremental Strategy
We replace the array k = n/c times
The total time T(n) of a series of n push
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 a push operation is O(n)

Elementary Data Structures 7

Direct Analysis of the
Doubling Strategy
We replace the array k = log2 n
times
geometric series
The total time T(n) of a series
of n push operations is 2
proportional to 4
n + 1 + 2 + 4 + 8 + …+ 2k = 1 1
n + 2k + 1 1 = 2n 1
8
T(n) is O(n)
The amortized time of a push
operation is O(1)

Elementary Data Structures 8

Accounting Method Analysis
of the Doubling Strategy
The accounting method determines the amortized
running time with a system of credits and debits
We view a computer as a coin-operated device requiring
1 cyber-dollar for a constant amount of computing.

 We set up a scheme for charging operations. This is

known as an amortization scheme.
 The scheme must give us always enough money to
pay for the actual cost of the operation.
 The total cost of the series of operations is no more
than the total amount charged.
(amortized time)  (total $ charged) / (# operations)

Elementary Data Structures 9

Amortization Scheme for
the Doubling Strategy
Consider again the k phases, where each phase consisting of twice
as many pushes as the one before.
At the end of a phase we must have saved enough to pay for the
array-growing push of the next phase.
At the end of phase i we want to have saved i cyber-dollars, to pay
for the array growth for the beginning of the next phase.
$ $ $ $
$
$ $ $ $
$

0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

• We charge $3 for a push. The $2 saved for a regular push are

“stored” in the second half of the array. Thus, we will have
2(i/2)=i cyber-dollars saved at then end of phase i.
• Therefore, each push runs in O(1) amortized time; n pushes run
in O(n) time.
Elementary Data Structures 10
The Queue ADT (§2.1.2)
The Queue ADT stores arbitrary Auxiliary queue
objects operations:
Insertions and deletions follow  object front(): returns the
the first-in first-out scheme element at the front without
Insertions are at the rear of the removing it
queue and removals are at the  integer size(): returns the
front of the queue number of elements stored
 boolean isEmpty(): indicates
Main queue operations:
whether no elements are
 enqueue(object): inserts an stored
element at the end of the
queue Exceptions
 object dequeue(): removes and  Attempting the execution of
returns the element at the front dequeue or front on an
of the queue empty queue throws an
EmptyQueueException
Elementary Data Structures 11
Applications of Queues
Direct applications
 Waiting lines
 Access to shared resources (e.g., printer)
 Multiprogramming
Indirect applications
 Auxiliary data structure for algorithms
 Component of other data structures

Elementary Data Structures 12

Singly Linked List
A singly linked list is a
concrete data structure next
consisting of a sequence
of nodes
Each node stores
 element elem node
 link to the next node

A B C D

Elementary Data Structures 13

Queue with a Singly Linked List
We can implement a queue with a singly linked list
 The front element is stored at the first node
 The rear element is stored at the last node
The space used is O(n) and each operation of the
Queue ADT takes O(1) time r
nodes

f 

elements
Elementary Data Structures 14
List ADT (§2.2.2)

The List ADT models a Accessor methods:

sequence of positions  first(), last()
storing arbitrary objects  before(p), after(p)
It allows for insertion Update methods:
and removal in the  replaceElement(p, o),
“middle” swapElements(p, q)
Query methods:  insertBefore(p, o),
insertAfter(p, o),
 isFirst(p), isLast(p)
 insertFirst(o),
insertLast(o)
 remove(p)

Elementary Data Structures 15

Doubly Linked List
A doubly linked list provides a natural prev next
implementation of the List ADT
Nodes implement Position and store:
 element
link to the previous node elem

node
 link to the next node
Special trailer and header nodes

header nodes/positions trailer

elements
Elementary Data Structures 16
Trees (§2.3)
In computer science, a
tree is an abstract model Computers”R”Us
of a hierarchical
structure
A tree consists of nodes Sales Manufacturing R&D
with a parent-child
relation
US International Laptops Desktops
Applications:
 Organization charts
 File systems Europe Asia Canada
 Programming
environments

Elementary Data Structures 17

Tree ADT (§2.3.1)
We use positions to abstract Query methods:
nodes  boolean isInternal(p)
Generic methods:  boolean isExternal(p)
 integer size()  boolean isRoot(p)
 boolean isEmpty() Update methods:
 objectIterator elements()  swapElements(p, q)
 positionIterator positions()  object replaceElement(p, o)
Accessor methods: Additional update methods
 position root() may be defined by data
 position parent(p) structures implementing the
 positionIterator children(p) Tree ADT

Elementary Data Structures 18

Preorder Traversal (§2.3.2)
A traversal visits the nodes of a Algorithm preOrder(v)
tree in a systematic manner
visit(v)
In a preorder traversal, a node is
visited before its descendants for each child w of v
Application: print a structured preorder (w)
document
1
Make Money Fast!

2 5 9
1. Motivations 2. Methods References

6 7 8
3 4
2.1 Stock 2.2 Ponzi 2.3 Bank
1.1 Greed 1.2 Avidity
Fraud Scheme Robbery

Elementary Data Structures 19

Postorder Traversal (§2.3.2)
In a postorder traversal, a Algorithm postOrder(v)
node is visited after its
descendants for each child w of v
Application: compute space postOrder (w)
used by files in a directory and visit(v)
its subdirectories
9
cs16/

8
3 7
todo.txt
homeworks/ programs/
1K

1 2 4 5 6
h1c.doc h1nc.doc DDR.java Stocks.java Robot.java
3K 2K 10K 25K 20K

Elementary Data Structures 20

Amortized Analysis of
Tree Traversal
Time taken in preorder or postorder traversal
of an n-node tree is proportional to the sum,
taken over each node v in the tree, of the
time needed for the recursive call for v.
 The call for v costs $(cv + 1), where cv is the
number of children of v
 For the call for v, charge one cyber-dollar to v and
charge one cyber-dollar to each child of v.
 Each node (except the root) gets charged twice:
once for its own call and once for its parent’s call.
 Therefore, traversal time is O(n).
Elementary Data Structures 21
Binary Trees (§2.3.3)
A binary tree is a tree with the Applications:
following properties:  arithmetic expressions
 Each internal node has two  decision processes
children
 searching
 The children of a node are an
ordered pair A
We call the children of an internal
node left child and right child
Alternative recursive definition: a B C
binary tree is either
 a tree consisting of a single node,
or
D E F G
 a tree whose root has an ordered
pair of children, each of which is a
binary tree
H I

Elementary Data Structures 22

Arithmetic Expression Tree
Binary tree associated with an arithmetic expression
 internal nodes: operators
 external nodes: operands
Example: arithmetic expression tree for the
expression (2  (a  1) + (3  b))

 

2  3 b

a 1

Elementary Data Structures 23

Decision Tree
Binary tree associated with a decision process
 internal nodes: questions with yes/no answer
 external nodes: decisions
Example: dining decision

Want a fast meal?

Yes No

How about coffee? On expense account?

Yes No Yes No

Starbucks In ‘N Out Antoine's Denny’s

Elementary Data Structures 24

Properties of Binary Trees
Notation Properties:
n number of nodes  e = i + 1
e number of
 n = 2e  1
external nodes
 h  i
i number of internal
nodes  h  (n  1)/2
h height  e  2
h

 h  log2 e

 h  log2 (n + 1)  1

Elementary Data Structures 25

Inorder Traversal
In an inorder traversal a Algorithm inOrder(v)
node is visited after its left
subtree and before its right if isInternal (v)
subtree inOrder (leftChild (v))
Application: draw a binary visit(v)
tree
 x(v) = inorder rank of v if isInternal (v)
y(v) = depth of v inOrder (rightChild (v))

6

2 8

1 4 7 9

3 5

Elementary Data Structures 26

Euler Tour Traversal
Generic traversal of a binary tree
Includes a special cases the preorder, postorder and inorder traversals
Walk around the tree and visit each node three times:
 on the left (preorder)

 from below (inorder)

 on the right (postorder)

L  R 
B
2  3 2

5 1

Elementary Data Structures 27

Printing Arithmetic Expressions
Specialization of an inorder Algorithm printExpression(v)
traversal
 print operand or operator
if isInternal (v)
when visiting node print(“(’’)
 print “(“ before traversing left
subtree
inOrder (leftChild (v))
 print “)“ after traversing right print(v.element ())
subtree
if isInternal (v)
+ inOrder (rightChild (v))
  print (“)’’)

2  3 b
((2  (a  1)) + (3  b))
a 1
Elementary Data Structures 28
Linked Data Structure for
Representing Trees (§2.3.4)
A node is represented by
an object storing 
 Element
 Parent node
 Sequence of children B
nodes
Node objects implement  
the Position ADT
A D F
B

A D F

C E  
C E
Elementary Data Structures 29
Linked Data Structure for
Binary Trees
A node is represented by
an object storing 
 Element
 Parent node
 Left child node B
 Right child node
Node objects implement  
the Position ADT

B A D

A D    

C E C E

Elementary Data Structures 30

Array-Based Representation of
Binary Trees
nodes are stored in an array
1
A
…
2 3
B D

 let rank(node) be defined as follows:

 rank(root) = 1 4 5 6 7
E F C J
 if node is the left child of parent(node),
rank(node) = 2*rank(parent(node))
 if node is the right child of parent(node),
10 11
rank(node) = 2*rank(parent(node))+1
G H
Elementary Data Structures 31