Scribd
Upload
34 views9 pages

Elementary Data Structure

Uploaded by

kayisledesta
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
34 views9 pages

Elementary Data Structure

Uploaded by

kayisledesta
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 9

Elementary Data Structures

\Mankinds's progress is measured by the number of


things we can do without thinking."
Elementary data structures such as stacks, queues,
lists, and heaps will be the \of-the-shelf" components
we build our algorithm from. There are two aspects to
any data structure:
 The abstract operations which it supports.
 The implementatiton of these operations.
The fact that we can describe the behavior of our data
structures in terms of abstract operations explains why
we can use them without thinking, while the fact that
we have dierent implementation of the same abstract
operations enables us to optimize performance.
Stacks and Queues
Sometimes, the order in which we retrieve data is inde-
pendant of its content, being only a function of when
it arrived.
A stack supports last-in, rst-out operations: push and
pop.
A queue supports rst-in, rst-out operations: enqueue
and dequeue.
A deque is a double ended queue and supports all four
operations: push, pop, enqueue, dequeue.
Lines in banks are based on queues, while food in my
refrigerator is treated as a stack.
Both can be used to traverse a tree, but the order is
completely dierent.
1 1

2 3 5 2

4 5 6 7 7 6 4 3

Queue Stack

Which order is better for WWW crawler robots?


Stack Implementation
Although this implementation uses an array, a linked
list would eliminate the need to declare the array size
in advance.
STACK-EMPTY(S)
if topS] = 0
then return TRUE
else return FALSE
PUSH(S, x)
topS ]  topS ] + 1
S topS ]  x

POP(S)
if STACK-EMPTY(S)
then error \underow"
else topS ]  topS ] ; 1
return S topS ] + 1]

4 top

All are O(1) time operations.


Queue Implementation
A circular queue implementation requires pointers to
the head and tail elements, and wraps around to reuse
array elements.
ENQUEUE(Q, x)
QtailQ]]  x
if tailQ] = lengthQ]
then tailQ]  1
else tailQ]  tailQ] + 1
X X X

tail head

DEQUEUE(Q)
x = QheadQ]]
if headQ] = lengthQ]
then headQ] = 1
else headQ] = headQ] + 1
return x
A list-based implementation would eliminate the pos-
sibility of overow.
All are O(1) time operations.
Dynamic Set Operations
Perhaps the most important class of data structures
maintain a set of items, indexed by keys.
There are a variety of implementations of these dic-
tionary operations, each of which yield dierent time
bounds for various operations.
 Search(S,k) { A query that, given a set S and a
key value k, returns a pointer x to an element in
S such that keyx] = k, or nil if no such element
belongs to S .
 Insert(S,x) { A modifying operation that augments
the set S with the element x.
 Delete(S,x) { Given a pointer x to an element in
the set S , remove x from S. Observe we are given
a pointer to an element x, not a key value.
 Min(S), Max(S) { Returns the element of the to-
tally ordered set S which has the smallest (largest)
key.
 Next(S,x), Previous(S,x) { Given an element x
whose key is from a totally ordered set S , returns
the next largest (smallest) element in S , or NIL if
x is the maximum (minimum) element.
Pointer Based Implementation
We can also maintain a directory in either a singly or
doubly linked list.
L
A B C D E F

L A B C D E F

We gain extra exibility on predecessor queries at a cost


of doubling the number of pointers by using doubly-
linked lists.
Since the extra big-Oh costs of doubly-linkly lists is
zero, we will usually assume they are, althought it
might not be necessary.
Singly linked to doubly-linked list is as a Conga line is
to a Can-Can line.
Array Based Sets
Unsorted Arrays
 Search(S,k) - sequential search, O(n)
 Insert(S,x) - place in rst empty spot, O(1)
 Delete(S,x) - copy nth item to the xth spot, O(1)
 Min(S,x), Max(S,x) - sequential search, O(n)
 Successor(S,x), Predecessor(S,x) - sequential search,
O(n)
Sorted Arrays
 Search(S,k) - binary search, O(lg n)
 Insert(S,x) - search, then move to make space,
O(n)
 Delete(S,x) - move to ll up the hole, O(n)
 Min(S,x), Max(S,x) - rst or last element, O(1)
 Successor(S,x), Predecessor(S,x) - Add or sub-
tract 1 from pointer, O(1)
What are the costs for a heap?
Unsorted List Implementation
LIST-SEARCH(L, k)
x = headL]
while x <> NIL and keyx] <> k
do x = nextx]
return x
Note: the while loop might require two lines in some
programming languages.
DELETION
HEAD(L) X

INSERTION

LIST-INSERT(L, x)
nextx] = headL]
if headL] <> NIL
then prevheadL]] = x
headL] = x
prevx] = NIL
LIST-DELETE(L, x)
if prevx] <> NIL
then nextprevx]] = nextx]
else headL] = nextx]
if nextx] <> NIL
then prevnextx]] = prevx]
Sentinels
Boundary conditions can be eliminated using a sentinel
element which doesn't go away.
NIL

LIST-SEARCH'(L, k)
x = nextnilL]]
while x <> NILL] and keyx] <> k
do x = nextx]
return x
LIST-INSERT'(L, x)
nextx] = nextnilL]]
prevnextnilL]]] = x
nextnilL]] = x
prevx] = NILL]
LIST-DELETE'(L, x)
nextprevx]] <> nextx]
nextprevx]] = prevx]

You might also like