Lecture 2
A Simple Container Class
An abstract data type or ADT is a term used to refer to a class that is presented to other
programmers with information hiding. The presentation here shows a simple way of
constructing an ADT, which for many cases is all

Lecture 12
Graphs
A graph, like a tree, is a nonlinear data structure consisting of nodes and links between the
nodes. Nodes in a tree are somewhat orderlythe root is linked to its children, which are
linked to their children and so on until we reach the

Lecture 11
Priority Queues (Heaps)
In the real world, queues may not be the most practical implementations. For example, items
sent to a printer are placed in a queue but some print jobs may be more important than others
and should move to a higher priori

Lecture 13
Sorting Algorithms
Bubble Sort
In Lecture 3 we suggested the Big-O for a Bubble Sort was O(n). The algorithm has a worst
case and average case of O(n). In this Session well explore sorting in more detail, and present
some alternatives to the Bu

Session 3
Mathematics Review
During this course a number of mathematics concepts are used to enhance or prove data
structure theory. Mathematics up to but not including Calculus will be called upon in
pursuit of these proofs and ideas. This short section

Lecture 4
Vector and String STL Classes
Templates are covered in the C+ review (Lecture 1) for this course available on the course web
site. The data structures are often referred to as collections or containers. The Standard
Template Libray (STL) is a C+

Lecture 10
Double Hashing to Reduce Clustering
During collisions in our previous open-addressing method, the insertion function moves forward
from the original index until a vacant spot is found in the array. Searching for a vacant spot in
this manner is

Lecture 5
Lists
Our Container Data Structure was a convenient starting point (Lecture 2). Remember that the
order of the data isnt important with Containers. Also, as an alternative approach for deletion
of an item in a Container we could delete the item

Lecture 7
Trees
For large amounts of data the linear access time of lists is not efficient and exhibits O(n)
where n is the number of entries in the list. The binary search tree is the subject of this
session and can exhibit a worst case of O(log2n).
Sinc

Lecture 8
Tree Searching
In this session we will present two more types of Trees: AVL Trees and Splay Trees. But lets
consider some of the advantages of Trees as they have been presented in our previous session.
Remember that the goal of a good data struc

Lecture 14
Recursion
Recursion is the process of a subprogram calling itself. A clearly defined stopping state must
exist. Any recursive subprogram can be rewritten using other methods. Since a recursive
algorithm must have a well-defined stopping state o

Lecture 6
Stacks
Our textbook defines a stack as a list with the restriction that insertions and deletions
can be performed in only one position, called the top. Entry to a stack is accomplished
by a push operation, and removing an entry from a stack is c