Docstoc

Abstract Data Types _ADTs_

Document Sample
Abstract Data Types _ADTs_ Powered By Docstoc
					                Abstract Data Types




many slides taken from Mike Scott, UT Austin


CS 307 Fundamentals of                         1
Computer Science
                          Data Structures
Data structure is a representation of data
 and the operations allowed on that data.




 CS 307 Fundamentals of                       2
 Computer Science
                 Abstract Data Types
In Object Oriented Programming data and
 the operations that manipulate that data are
 grouped together in classes
Abstract Data Types (ADTs) or data
 structures or collections store data and allow
 various operations on the data to access and
 change it




 CS 307 Fundamentals of                      3
 Computer Science
                          Why Abstract?
Specify the operations of the data structure
 and leave implementation details to later
   – in Java use an interface to specify operations
many, many different ADTs
   – picking the right one for the job is an important
     step in design
   – "Get your data structures correct first, and the
     rest of the program will write itself."
             -Davids Johnson
High level languages often provide built in
 ADTs,
   – the C++ STL, the Java standard library
 CS 307 Fundamentals of                                  4
 Computer Science
                The Core Operations
Every Collection ADT should provide a way to:
   – add an item
   – remove an item
   – find, retrieve, or access an item
Many, many more possibilities
   –   is the collection empty
   –   make the collection empty
   –   give me a sub set of the collection
   –   and on and on and on…
Many different ways to implement these items each
 with associated costs and benefits

 CS 307 Fundamentals of                          5
 Computer Science
                  Implementing ADTs
when implementing an ADT the operations
 and behaviors are already specified
   – think Java interface
Implementer’s first choice is what to use as
 the internal storage container for the
 concrete data type
   – the internal storage container is used to hold the
     items in the collection
   – often an implementation of an ADT
   – initially slim pickings for choice of storage
     containers: arrays anyone?
 CS 307 Fundamentals of                              6
 Computer Science
                          The Grand Tour
Why study ADTs?
Why reimplement some of them?
How many of you will actually go out and
 create your own linked list ADT from
 scratch?
Remember, the primary goal is to learn how
 to learn how to use and create ADTs
   – also learn the behavior of some of the more
     conventional ADTs

 CS 307 Fundamentals of                            7
 Computer Science
                          Bags and Sets
Simplest ADT is a Bag
   – items can be added, removed, accessed
   – no implied order to the items
   – duplicates allowed
Set
   – same as a bag, except duplicate elements not
     allowed
   – union, intersection, difference, subset



 CS 307 Fundamentals of                             8
 Computer Science
                          Lists
Items have a position in this Collection
   – Random access or not?
Array Lists
   – internal storage container is native array
Linked Lists
public class Node
{ private Object data;
  private Node next;                 last
}          first


 CS 307 Fundamentals of                           9
 Computer Science
                          Stacks
Collection with access only to the last
 element inserted
                          Data4            Top
Last in first out
                          Data3
insert/push
remove/pop               Data2

top                      Data1

make empty



 CS 307 Fundamentals of                      10
 Computer Science
                              Queues
Collection with access only to the item that
 has been present the longest
Last in last out or first in first out
enqueue, dequeue, front
priority queues and deque
      Front                                Back


      Data1               Data2   Data3   Data4

 CS 307 Fundamentals of                           11
 Computer Science
         Stacks and Queues in the
            Java Collection API
No queue in the Java collections ADT
Stack extends Vector (which is almost
 exactly like ArrayList)
   – Hmmm?
One reason the Java Collections Library is
 often said to be broken
no Queue in Collection API

CS 307 Fundamentals of                    12
Computer Science
                         Trees
Similar to a linked list
public class TreeNode
{ private Object data;
  private TreeNode left;
  private TreeNode right;
                                 Root
}




CS 307 Fundamentals of                  13
Computer Science
                Other Types of Trees
Binary Search Trees
   – sorted values
Heaps
   – sorted via a different algorithm
AVL and Red-Black Trees
   – binary search trees that stay balanced
Splay Trees
B Trees


 CS 307 Fundamentals of                       14
 Computer Science
                          HashTables
Take a key, apply function
f(key) = hash value
store data or object based on hash value
Sorting O(N), access O(1) if a perfect hash
 function and enough memory for table
how deal with collisions?




 CS 307 Fundamentals of                    15
 Computer Science
                          Other ADTs
Maps
   – a.k.a. Dictionary
   – Collection of items with a key and associated
     values
   – similar to hash tables, and hash tables often
     used to implement Maps
Graphs
   – Nodes with unlimited connections between other
     nodes
Sparse vectors and sparse matrices
 CS 307 Fundamentals of                              16
 Computer Science
            The Java Collection
                  Interface
boolean isEmpty()
int size()
boolean add(Object x)
boolean contains(Object x)
boolean remove(Object x)
void clear()
Object[] toArray()
Iterator iterator()
CS 307 Fundamentals of            17
Computer Science
                   Generic Containers
ADTs or Collection classes should be
 generic
   – only write them once, hold lots or all types of
     data
   – Java achieves genericity through inheritance and
     polymorphism
ADTs have an internal storage container
   – What is storing the stuff,
   – implementation vs. abstraction
   – in Java, usually holds Objects. Why?
 CS 307 Fundamentals of                           18
 Computer Science
CS 307 Fundamentals of   19
Computer Science
  java.util   Example - ArrayList
  Class ArrayList
  java.lang.Object
    |
    +--java.util.AbstractCollection
          |
          +--java.util.AbstractList
                |
                +--java.util.ArrayList
  All Implemented Interfaces:
        Cloneable, Collection, List, Serializable

        void add(int index, Object element)
                       Inserts the specified element at the specified position in this list.
   boolean add(Object o)
                       Appends the specified element to the end of this list.
   void clear()
                   Removes all of the elements from this list.
   boolean contains(Object elem)
                Returns true if this list       contains the specified element.
         int indexOf(Object elem)
                      Searches for the first occurence of the given argument, testing for
                equality using the equals method.
   boolean isEmpty()
                       Tests if this list has no elements.
  Object set(int index, Object element)
                    Replaces the element at the specified position in this list with the
              specified element.
    int size()
CS 307 Fundamentals of
             Returns the number of elements in this list.
                                                                                               20
Computer Science

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:0
posted:4/5/2013
language:Unknown
pages:20