Transcript ADTs

CS 261 – SUMMER 2011
Abstract Data Types
Container Classes
 Over the years, programmers have identified
a small number of different ways of
organizing collections of data.
 These container abstractions are now the
fundamental heart of the study of data
structures.
 Examples, Stack, Queue, Set, Map, etc
Three Levels of Abstraction
 There are at least three levels of abstraction
in the study of data structures
 ADT - Abstract Data Type, language
independent
 Interface - the interface in a particular library
of containers
 Implementation - the various
implementations in a particular library
The ADT view
(Abstract Data Type)
 Every data type can be described in a way
that is independent of language/library
 E.G., A Stack is a collection that has the
property that an item removed is the most
recently entered item.
 Properties that are true regardless of the
names given to operations in library
Metaphors
 ADT view are often described by metaphors
(e.g., stack of plates). Easy to remember.
Easy to understand.
The Interface View
 Gives specific names to operations
struct stack;
void initStack (struct stack * stk);
void pushStack (struct stack * stk, double val);
double topStack (struct stack * stk);
void popStack (struct stack * stk);
int isEmptyStack (struct stack * stk);
Additional Information
 The interface view gives only signatures
 Must also attach meanings (LIFO properties
of stack, etc)
 Can also attach expected execution times
(want push and pop to be constant time).
 Both more and less informative than ADT
view
The Implementation View
void pushStack (struct stack * stk, double val) {
stk->data.add(val);
}
int stackIsEmpty (struct stack * stk) {
return dyArraySize(stk->data) == 0:
}
The Study of Data Structures
 As we study data structures we move
constantly between all three views
 The ADT view is constant from one language
to the next
 The interface view allows you to compare
implementations
 The implementation allows you to see how it
is done
The Classic ADTs
 Bag, Ordered Bag - simple collections
 Stack, Queue, Deque - ordered by insertion
 Set - unique elements, fast test
 Map (Dictionary) - key/value associations
 Priority Queue - ordered by importance
BAG as Design Pattern
 Problem: Need to maintain an unordered
collection of elements, without needing to
know how it is organized
 Forces: Require insertion, test and removal time of insertion is unimportant
 Counter-forces: Time of insertion IS
important
 Solution: Provide abstract interface
BAG interface
 Provide functions for operations, effectively
hiding implementation (names may vary)
addBag (container, value)
testBag (container, value)
removeBag (container, value)
sizeBag (container, value)
Stack as Design Pattern
 Problem: Maintain collection in Last-In, First-
Out format
 Forces: LIFO
 Counter-forces: non-LIFO
 Solution: again, abstract Stack interface
The Classic Implementation
Techniques
 Arrays and Dynamic Arrays (Vectors)
 Linked Lists
 Binary Trees, Balanced Trees
 Heaps
 Hash Tables
 Skip Lists
 Etc etc etc
Now, your first worksheet
 As a way to introduce C and the worksheet
idea, we will make implementations of a
simple BAG and STACK using an array
 We will do these together, in class - won’t
always be that way
 Worksheets are handed in, and are lightly
graded.
First look at C - interface
file
# define EleType double
# define EQ(a, b) (a == b)
struct arrayBag {
EleType data[100];
int count;
};
void initBag (struct arrayBag * b); … etc
First function - initialize
void initBag (struct arrayBag * b)
{
}
Add to bag
void addBag (struct arrayBag * b, EleType v)
{
}
Test for contains
int testBag (struct arrayBag * b, EleType v)
{
}
Remove from bag
void removeBag (struct arrayBag * b, EleType v)
{
}
Return size of collection
int bagSize (struct arrayBag * b)
{
}
How about stack?
void pushStack (struct arrayBag * b, EleType v)
{
}
Test for stack empty
int isStackEmpty (struct arrayBag * b)
{
}
Top of stack
EleType topStack (struct arrayBag * b)
{
}
Pop top element
void popStack (struct arrayBag * b)
{
}
That’s all for today
 Hand in your worksheets, put your name on
them