Download Chapter 3

Chapter 3
List Stacks and Queues
Data Structures

Data structure is a representation of data and
the operations allowed on that data.
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
The Core Operations

Every Collection ADT should provide a way to:




Many, many more possibilities





add an item
remove an item
find, retrieve, or access an item
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

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?

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
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

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;
}

first
last
Stacks






Collection with access only to the last element
inserted
Top
Last in first out
Data4
insert/push
Data3
remove/pop
Data2
top
Data1
make empty
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
Data1
Back
Data2
Data3
Data4
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
Trees
Similar to a linked list
public class TreeNode
{ private Object data;
private TreeNode left;
private TreeNode right;
}

Root
Other Types of Trees

Binary Search Trees


Heaps



sorted via a different algorithm
AVL and Red-Black Trees


sorted values
binary search trees that stay balanced
Splay Trees
B Trees
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?
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
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()
Interface?????
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?

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()
Returns the number of elements in this list.