Docstoc

ADTs Classes

Document Sample
ADTs Classes Powered By Docstoc
					CS 261 - Winter 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

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:3/30/2013
language:English
pages:26
dominic.cecilia dominic.cecilia http://
About