Schedule (Tentative!)
- Stuff listed in bold indicates a due date of some sort, attached to a grade item that will influence your final grade. See Assessment for more details.
Week 1: Introduction and Overview (September 7 – September 10)
Lecture:
- Thursday: Welcome to Data Structures (and Algorithms :-)
- Friday: Classes, Generics, Exceptions, Interfaces: Hacking Arrays in Java
Resources:
- Code from Lecture 2 (edited and extended)
Reading:
- Required: Goodrich 1: Java Programming Basics; 2: Object-Oriented Design
- Recommended: Java 5.0 in a Nutshell
- Optional: ACM Code of Ethics and Professional Conduct
Tasks:
- Thursday: Grab Assignment 1 and get started.
- Friday: Introduce yourself on the course mailing list.
Week 2: Theoretical Background (September 11 – September 17)
Lecture:
- Thursday: Algebraic Specification of Abstract Data Types (Variables, Arrays)
- Friday: Basics of Algorithm Analysis (linear search, binary search, bubble sort, selection sort)
Resources:
Reading:
- Required: Goodrich 3: Arrays, Linked Lists, and Recursion; 4: Analysis Tools
- Recommended: Generics in the Java Programming Language (PDF)
- Optional: A Brief History of the Green Project
Deadlines:
- Thursday: Turn in your solution to Assignment 1.
- Thursday: Grab Assignment 2 and get started.
- Friday: Take and defend a position regarding "What's better? Asymptotic or Experimental Analysis?" on the course mailing list; discuss.
Week 3: Fundamental Data Structures (September 18 – September 24)
Lecture:
- Thursday: Sparse & Growing Arrays, Amortized Analysis, Specification and Implementation of Stacks, Bounded versus Unbounded Stacks (Part 1)
- Friday: Bounded versus Unbounded Stacks (Part 2), Interfaces as Contracts, Queues and Deques
Reading:
- Required: Goodrich 5: Stacks and Queues
- Recommended: Java Virtual Machine (and links from there)
- Optional: Stack-oriented programming languages (and links from there, especially Forth)
Deadlines:
- Thursday: Grab Assignment 3 and get started.
- Friday: Turn in your solution to Assignment 2.
- Friday: Take and defend a position regarding "Peter is nuts! Distinguishing bounded and unbounded stacks with separate Java interfaces is overkill." on the course mailing list; discuss. The code for this is in the archive for Assignment 3. Some background reading (if you feel like it): The Liskov Substitution Principle (LSP) is summarized here; specific examples are discussed in this paper.
Week 4: Linear Data Structures (September 25 – October 1)
Lecture:
- Thursday: Position-based versus Value-based Data Structures; Positions for Stack, Queue, Array; Overview of Lists and Abstract Positions; Random vs. Sequential Access; Design of List and Position Interfaces; Implementation using Nested Classes
- Friday: More List Stuff; Iterators; Reference Counting
Reading:
- Required: Goodrich 6: Lists and Iterators
- Recommended: Unrolled Linked Lists
- Optional: In Scheme (almost) everything is a list (or a function, depending on how you look at it)
Deadlines:
- Thursday: Turn in your solution to Assignment 3.
- Thursday: Grab Assignment 4 and get started.
- Friday: Read up on XOR Linked Lists. Discuss on the mailing list under what circumstances it might be a good idea to use this data structure. How would you implement the position or iterator abstraction? Is it possible to implement this data structure in Java?
Week 5: Hierarchical Data Structures (October 2 – October 8)
Lecture:
- Thursday: Introduction to Trees, Terminology, General Trees, Binary Trees, Implementation Sketch, Interface Design
- Friday: Midterm 1 (Sample Solution); Tree Traversals; Parameterized Traversals and the Template Method Pattern
Reading:
- Required: Goodrich 7: Trees
Deadlines:
- Thursday: Turn in your solution to Assignment 4.
- Thursday: Grab Assignment 5 and get started.
- Friday: Take and defend a position regarding "To Munge or Not To Munge: The Dreaded Reply-To Header" on the course mailing list; discuss. Here is some background reading: [Rosenthal: "Reply-To" Munging Considered Harmful] [Bernstein: Mail-Followup-To and Mail-Reply-To]
Week 6: Graph Data Structures (October 9 – October 15)
Lecture:
- Thursday: Introduction to Graphs, Applications, Terminology, Interface Design
- Friday: Implementation Options, Graph Traversals (Depth First Search, Breadth First Search)
Reading:
- Required: Goodrich 13: Graphs (except 13.6 and 13.7)
- Recommended: Social Networks
- Optional: The Erdös Number Project
Deadlines:
- Friday: Turn in your solution to Assignment 5.
- Friday: Grab Assignment 6 and get started.
- Friday: Present an application of graphs on the course mailing list. It's up to you which application to present, but you have to present something that nobody else has presented on the mailing list before. If you post something and then find that someone else posted the same application earlier (perhaps while you were still working on your email) you have to find a new application to present. However, once you have presented an application, you can post more details about it any time before Friday is over. If you get your application from an online source, cite the source and give a URL for it. It's okay to present an application from the text book or from lecture as well...
Week 7: Sets and Priority Queues (October 16 – October 22)
Lecture:
- Thursday: Sets as Abstract Data Types, Multisets (aka Bags), Basic Implementations, Ordered Sets, Self-Organizing Sets: Move-to-Front and Transpose Heuristics
- Friday: Ordered Sets with Minimum and Maximum, Heaps, Priority Queues
Reading:
- Required: Goodrich 8: Priority Queues; 11.6 for a different take on sets; 13.6 and 13.7 to see where priority queues are useful
- Optional: Check out this representation for sets of integers; think about how to do this in Java maybe? :-)
Deadlines:
- Friday: Turn in your solution to Assignment 6.
- Friday: Grab Assignment 7 and get started.
- Friday: Discuss the Move-to-Front and Transpose heuristics for implementing self-organizing sets on the course mailing list. Outline under what assumptions you should go for self-organizing sets and how you would decide whether to use Move-to-Front or Transpose for a particular application. If you find other heuristics online, feel free to discuss those as well, but cite your sources!
Week 8: Maps and Hash Tables (October 23 – October 29)
Lecture:
- Thursday: Maps as Abstract Data Types, Interface Design, Introduction to Hash Tables, Hash Functions, Collisions
- Friday: Hash Table Implementation, Load Factors and Rehashing
Reading:
- Required: Goodrich 9: Maps and Hash Tables
- Optional: Bloom Filters are another cool data structure based on hashing
Deadlines:
- Friday: Turn in your solution to Assignment 7.
- Friday: Grab Assignment 8 and get started.
Week 9: Search Trees (October 30 – November 5)
Lecture:
- Thursday: Ordered Maps, Binary Search Trees, (2,3) Trees
- Friday: AVL Trees
Reading:
- Required: Goodrich 10: Search Trees
- Optional: Check out Randomized Binary Search Trees (which are very different from plain binary search trees on which insertions are performed in random order). Nice applet too... :-) Speaking of applets, check out this Beautiful Balanced Tree Applet, it can be quite helpful...
Deadlines:
- Friday: Turn in your solution to Assignment 8.
- Friday: Grab Assignment 9 and get started.
Week 10: Sorting and Selection (November 6 – November 12)
Lecture:
- Thursday: Heap Sort, Merge Sort
- Friday: Project Introduction, Subversion, Quick Sort
Reading:
- Required: Goodrich 11: Sorting and Selection
- Optional: Version Control with Subversion
Deadlines:
- Monday: Post your idea for a final project in the course. Be sure to describe it in enough detail for others to understand what you're suggesting. Don't just say "MapQuest" for example, explain with a few sentences what the system you'd like to build would do for users. Don't just say "some game" but give details instead, maybe pointing to existing games and telling us what would be different for your version.
- Friday: Turn in your solution to Assignment 9.
- Friday: Email us your team registration for the final project. Include the names and email addresses of all three team members! Include three possible meeting time slots (of one hour each) that all of you can make, in order of preference! Be sure to cc all team members! And pick a decent name for your team, otherwise we'll pick one for you... :-)
- Friday: Grab Assignment 10, the first part of the "big project," and get started.
Week 11: Text Processing (November 13 – November 19)
Week 12: Thanksgiving! (November 20 – November 26)
Thanksgiving Vacation is November 23 – November 26!
You still have classes Monday, Tuesday, and Wednesday!
Week 13: Memory and Files (November 27 – December 3)
Week 14: Review and Outlook (December 4 – December 10)
Week 15: The Lost Week (December 11)
Technically part of the semester, but we don't have lecture on Monday. :-)
