CS 210 Fall 2007

Java Language Reference

as mentioned in class, there's a lot of very useful information on Java available on the web, particularly for Collections. Here's the reference to the Sun Java website Guide for Collections. Take a look.

Tutorial, perhaps a good place to get your feet wet

API Specification (application programming interface), lists all the Collections classes (and interfaces), and then gets down to specifics on every method -- its name, what it does, what arguments it accepts etc. This is really valuable reference material whenever you need to use one of these classes.

Overview, including some design rationale and discussion of benefits. Some useful summary stuff, too.

Review Material

  Some of these questions will be on the final exam

  Review of term -- prep for Final Exam

A collection of highlights and suggestions that may be helpful as you summarize the term .. and prepare for the upcoming final.

Assignments

Current

Item/List project (13-16)

Item/List project - Garbage Collector description (16)

Item/List project - Extended Eval (with variables, etc.(17)

Assignment 13-16: basic source for program is in This directory (.java and .zip form)

This assignment (part one of a larger product) is due Monday Nov 26.

unpack/download the program, run it, figure out what's happening. (Note: this incudes an updated Tokenizer -- please use the new copy). (Note: requires Java 1.5 at least)

Add (recursive) functions to calculate the length of a list, the number of Items in a whole structure (list and sublists)

Assignment 14: run timing tests on various Sort programs
Due Wednesday, Nov 28.

Assignments 10 - 14 are described on a separate page

Here's some previous comments about the assignments ...
For the week of of 12 Nov:
add various capabilities to the base binary tree program.

complete the work of evaluating time performance, begun last week.

fix the "preorder" print to be more useful, in particular print each item on a separate line with some kind of level indication -- level number and/or indentation.

write a function to determine the total number of nodes in the tree.

write a function to determine the maximum depth of the tree.
(note that it is possible to keep track of some of these things while building the tree. That's fine, if you want to do that. But please ALSO provide separate functions to enquire into already-built trees. Note these will want to be recursive)

coming up in the future, not to worry for this week: breadth-first walk of tree

Due Wednesday 7 Nov:
Pick up Lafore's "tree" program from the "binary tree" chapter. Run it, become familiar with it.
Additionally, begin to add some performance evaluation code, as discussed in class on Monday 5 Nov.

Previous

Due Wednesday 31 Oct:
Implement the hash table program as found in Lafore, p. 555. Get it to run, and make sure you understand how it's put together. We might add something to it.

There is no new programming assignment the week leading into the Hour Exam.
If you have not submitted homeworks 3, 4, and 5 already, please get them working and turned in! This will help you prepare for the exam. (also, these homeworks will not be accepted after the exam.)

For those of you who are interested, here is the Towers of Hanoi source used for demonstration in class Monday.

Assignment five:

Text of assignment five: insertion sort on doubly-linked list (as described in class)

Assignment four:

Text of assignment four: simple stack calculator (as described in class)

material: ST2 source, also StackX source

Assignment three:

Text of assignment (as handed out in class)

Assignment two:

Text of assignment

Program core, as supplied (Java file)

HOUR EXAM

An hour exam is scheduled for Wednesday, Oct 24 during class.

Sample Problems

. Some of these problems will be on the exam.
Some additional problems will be added to this list shortly. An email will be sent out to let you know when this has happened.

The exam will be closed-book.

As this is a programming course, it's reasonable to expect that you'd have to write a [short] program or two.

Upcoming Lecture Material

Wed (Oct 17): Hash tables, building on the idea of an array of lists. Interesting terms: "load factor", "collision". (covered in Lafore, ch. 11; but we'll focus on what he calls "Separate Chaining" (p. 552 ff), though we'll also discuss "Open Addressing")
On Mon (Oct 15), continue with recursion and lists. Look at Towers of Hanoi problem, an excellent example of recursion. Also look at idea of accumulating data using an array of lists, rather than a single list.
On Wedn (Sept 26), more stacks, also queues. Soon we'll start Recursion, which lives in chapter 6.
On Monday (Sept 24), look at Stacks, and a new version of Tokenizer; also type Object, and subclass qualification.
On Monday (Sept 17), we'll be continuing with Chapter 3 and chapter 2 of Lafore:

simple sorts - insertion, selection, bubble

binary sort

Miscellaneous things

Initial day assessment

Overview of Data Structures, from Lafore ch. 1