**COURSE TIMES:**

- Section 1: Tuesday and Thursday, 9:30 - 10:45 AM, ECS-136.
- Section 2: Tuesday and Thursday, 12:30 - 1:45 PM, ECS-134.
- Section 3: Tuesday and Thursday, 5:00 - 6:15 PM, ECS-235.
- Section 4: Tuesday and Thursday, 6:25 - 7:40 PM, VH-173A.

**PREREQUISITES:**
Discrete Math and COP-3337 from no earlier than Summer/Fall 2001.
You
**must**
drop the course
if you haven't gotten a C or better in an applicable computer course above.
You might
want to drop if you haven't had Discrete Math.

**INSTRUCTOR:**
Prof. Mark Allen Weiss

**OFFICE HOURS:**
You are free to stop by my office (ECS-355) any time you can find me.
My office hours represent a time when I am (more or less)
guaranteed to be available.
This semester this is
Tuesday and Thursday, 11:00 - 12:00 noon and 3:50 - 4:50 PM,
and after 7:50 PM (but only if students are waiting).
My office phone is FIU-2036.

On other days, and after hours, you are better off trying email: . You will generally get an answer within 10 minutes of my reading the message.

I have three standing rules:

- I will not debug programs. Debugging is part of the assignment. If you are very confused about some compiler error messages, you can ask, but read the error message carefully and ask as a last resort, not a first. Also, check the announcements page, since I occasionally post answers to common problems reported to me.
- If you miss class, get the class notes from a classmate or check the lectures page. Do not ask me what you missed.
- I am very unsympathetic toward questions that are asked on the program due date. You should be done by then.

**LANGUAGES AND PLATFORMS:**
This course will be conducted in Java.
I assume that you are reasonably well-versed in Java,
having had Programming II in Java.
**
If you have not recently programmed in Java, you will
probably have a very difficult time in this course.**
You must use a compiler that supports
Java 1.3 or higher.

**TEXT:**
The course text
is my book
*Data Structures, and Problem Solving with Java, Second Edition*.
There are no other texts required or recommended.
This edition is significantly revised from the first edition and I do not recommend
using the first edition.

**COURSE GRADING:**
Grades will be based on six programs,
quizzes based on the programs, one exam
(graded prior to the Oct 18 drop date),
a possible pre-final, and a final
examination. The exam(s) are worth 2 programs,
the final is worth 3 programs,
and each quiz is worth half a program.
The prefinal, if it occurs, will be worth 100 points.
You need 70% to get a C.
I reserve the right to change the method of assigning grades,
including changing the number of assignments or exams,
but
**in no case will a curve be applied**.

**PROGRAMS:**
Barring tragedy, I will not accept late programs.
Your submission must include
source code and
sample output.
I will generally specify what the data is.
Your work must be your own, and you must attest to this
in a signed comment that begins each program.
See also FIU's
Code of Academic Integrity.
The assignments and if appropriate, input data, will
be placed
here.
I expect a professional submission.
This means
**you will lose points for nonsense such as**
not including the disclaimer, with your name, typed at the start of the program
and
not binding the pages of your submission in a reasonable way.

**COURSE OUTCOMES**

- Be familiar with basic techniques of algorithm analysis
- Be familiar with writing recursive algorithms
- Master the implementation of linked data structures such as linked lists and binary trees
- Be familiar with advanced data structures such as balanced search trees, hash tables, priority queues and the disjoint set union/find data structure
- Be familiar with several sub-quadratic sorting algorithms including quicksort, mergesort and heapsort
- Be familiar with some graph algorithms such as shortest path and minimum spanning tree
- Master the standard data structure library of a major programming language (e.g.
`java.util`in Java 1.2) - Master analyzing problems and writing program solutions to problems using the above techniques

**COURSE OUTLINE (OPTIMISTIC):**

- Brief review of Java.
- Introduction to Patterns
- Algorithms - What they are and what are their time and space complexities. Big-Oh notation. Computation of complexities of an algorithm.
- Lists, Stacks, Queues, Trees, binary search trees, AVL trees, B-trees.
- Hash Tables, Binary heaps, heapsort,
- Sorting Algorithms: Insertion sort, Shellsort, mergesort, quicksort, bucket sort. Lower bounds for sorting.
- Disjoint set UNION-FIND algorithm, Graph Algorithms: Minimum spanning tree, shortest path algorithms.