----------------------------------------------------------------------------
COMP SCI 731 - Data Struc & Algorithms - Lecture 1 - Friday, June 23, 2000
----------------------------------------------------------------------------
Today: [ ] Opening remarks
[ ] Stacks and their use
Introduction
------------
o Please tell me who you are. Write your name in English and Thai,
then your nickname, and then some sentence or two to help me remember
you.
o I do this....
o Graduate-level course on data structures and algorithms.
Data structures and algorithms intertwined: interesting algorithms
require non-trivial data structures to support them, and
data structures by themselves are useless -- only by supporting an
algorithm does a data structure accomplish anything.
o Homeworks of two types: programs and written problems.
Some of the programs will be designed for you to discover something.
You can write the programs in any language you wish, but I think
most of you will choose to use C or C++.
o I will select material from various books, particularly:
- Corman, Leiserson, Rivest: Introduction to Algorithms
- Kozen: The Design and Analysis of Algorithms
- Weiss: Data Structures and Algorithm Analysis [in C++]
When I follow closely from a book, I will give you copies
of the material. You can also borrow any of these books from
me; get it from my office.
o Grading: 30% midterm, 40% final, 20% homework, 10% attendance
o Please come visit me, talk to me. You must tell me what is
going on. I do not know your background. It is very easy for
me to accidentally go too fast, to make the class too hard,
or to use English that is too difficult. If you are not
understanding, I want to know.
o Topics include: stacks and queues; disjoint sets; Fibonacci heaps;
splay trees; search trees; graph algorithms; dynamic programming;
greedy algorithms; hashing; string matching; ??? If you have
topics requests, please tell me and I will try to find time.
Stacks
------
Stacks are probably the most widely used data structure, insofar as
almost every executing program employs one: the runtime stack
that keeps the stack frames (activation records) of local variables.
Stacks are used to record a sequence of *deferred obligations*.
Something happens that generates an obligation to do something.
You will get to it -- but in a little while, becase there are other
obligations to take care of, too. With a stack, the most recently
generated obligation is serviced first (LIFO: last-in, first-out).
To compare, a queue is also used to generate deferred obligations,
but those obligations are serviced in a FIFO order: first-in,
first out.
When you think about something like a stack do NOT think of it by
thinking in terms of any specific implementation. Think of it in
terms of an abstract data type (ADT). Remember that an ADT is
collection of data and a collection of operations which
manipulate that data.
ADT Stack [of type T]
Data: A number n>=0 and a sequence a_1, ..., a_n of elements,
each element being of type T.
Initially (when the stack is created) n=0.
Operations: Boolean Empty() - return true if n==0, false otherwise
void Push(T item) - increment n and then set a_n = item
T Pop() - if n==0 then ERROR. Otherwise,
item=a_n, n--, and return item
Above we are giving the operational semantics. We are not meaning
to imply anything about the implementation! There are many ways to
implement a stack, and we will later talk about that. But sing a stack
doesn't require you to know anything about how the stack is to be
implemented. This is a general characteristic of using ADTs:
understand the data and the operations, and then use the ADT.
You should not think about how the ADT is implemented when you are
using it. Respect the abstraction boundary.
Example 1: Evaluating a Postfix ("reverse Polish noation - RPN") expression:
Prefix: - * + 4 5 3 2
Infix: (4+5)*3-2
Postfix: 4 5 + 3 * 2 - <===
When you see an operand n, push it onto the stack.
When you see a binary operator Op, pop the top stack entry
into y, pop the next stack entry into x, apply the
operator to get z=x Op y, and push z onto the stack.
Generate an error if the stack is ever empty when you want to
pop, or if the stack contains anything but one entry when you
are done. That one entry is the answer.
| | | | | | | | | | | | | | | |
| | | | |5 | | | |3 | | | |2 | | |
| | |4 | |4 | |9 | |9 | |27| |27| |25|
|__| |__| |__| |__| |__| |__| |__| |__|