This page summarizes the lectures and mentions the suggested reading assignments.
This summary is quite brief, and its intention is to help the student and
instructor recollect what was covered. It is no substitute for participating
in the lectures.
- Lecture 1: An introduction to a program in Java, and how to create
a java application project in the netBeans IDE via the
hello world program.
A discussion of primitive types.
- Lecture 2: packages, classes, instance variables and methods, static methods, and
objects, and the syntactic structure of a program in Java via
this program. Discussion of
- Lecture 3: Array declaration, creation, arrays are objects idea, syntax of for, while,
and if-else constructs, instantiation of inputs to method calls via
this program. Also a discussion of
reading input from the standard input, from Section 1.6 of the text.
- Reading assignment for Week 1: First chapter of textbook.
- Lecture 1: An introduction to inheritence and polymorphism via
- Lecture 2: We continue on inheritence and polymorphism via an example that is basically from Section
2.2 of the text.
- Lecture 3: Completion of the previous example.
- Reading assignment for Week 2: An overview
of Section 2.1, followed by a thorough understanding of 2.2 and 2.3 is
- Lecture 1: Designing a class for
storing a text document. Note that the class is under development
and will be modified as we go along.
- Lecture 2: Continuing on the same example.
- Reading assignment for Week 3: A different example that covers some of
the same ideas as our example is Section 3.1.1 of the text. Studying
this is recommened.
- Lecture 1: An introduction to linked lists, based on Section 3.2 of
the text. Writing a class for a
singly linked list.
- Lecture 2: Finishing the linked list discussion, talking about Homework 3,
and introducing Recursion based on Section 3.5.
- Lecture 3: Recursion example using Fibonacci Sequences (Section 3.5), and
an introduction to recursive thinking via a modification of the printList
method in our class for a
singly linked list. (The modification is not shown here.)
- Reading assignment: Sections 3.2, 3.3, and 3.5.
- Lecture 1: We'll introduce the idea of primitive operations and running
time analysis by looking at this Multiset
- Lecture 2: Completing the introduction and the example. big-Oh notation. Significance
of asymptotic analysis and the way we'll use it. O(n) can show up as running time
ways different from a for loop that iterates n times.
- Lecture 3: Examples of running time analysis and algorithm design: Prefix Averages, and
Element Uniqueness from Section 4.2.
- Reading assignment: Sections 4.1 and 4.2. The focus should
be on 4.2, and 4.1 is supplemental.
- Lecture 1: Element Uniqueness - exponential, quadratic, and sorting-based solutions from
- Lecture 2: Midterm
- Lecture 3: The logarithm function, how it appears in running time analysis. Beginning Chapter
5, along with interfaces (Section 2.4) and generics (Section 2.5).
- Lecture 1: The Stack Abstract Data Type (ADT), describing the methods of the ADT in an
interface. A class that uses an array to implement this interface. This is a non-generic
version that will build up to the generic one in Section 5.1 of the book.
- Lecture 2: Continuing on the stack class from earlier. An application to checking well-formedness,
which is similar to 'Matching tags in a HTML document' from the text.
- Lecture 3: Making the stack interface and class generic.
- Reading for this week: Sections 2.4, 2.5, and 5.1.
- Lecture 1: More examples instantiating the generic stack we constructed. Running time. Limitations
of array based stack. Getting around these, and implications for running time. Linked-list
based implementations. Introduction to the Queue ADT.
- Lecture 2: Discussion of an array-based queue implementation, and the
The Collection and List interfaces in Java, and the classes ArrayList
and LinkedList that implement these -- we base this off `Notes on Lists
and Iterators' in the content section of our ICON page, instead of the
textbook, where it corresponds to Sections 6.1, 6.3, and 6.4.
- Lecture 3: ArrayLists, LinkedLists, and iterators.
- Reading assignment: Sections 2.4, 2.5, and 5.2.
- Lecture 1: A study of iterators and List-iterators, via this example.
- Lecture 2: Introducing the map ADT and interface from Chapter 9. An
example of the use of a class HashMap that implements a map-like interface. Laying the groundwork for a hash-table based implementation of the map ADT.
- Lecture 3: Completing our sketch of a linked list based implementation
of the Map ADT. Hash Table based implementation.
- Reading assignment: Sections 6.1 (you can skip 6.1.2), 6.3 (you can skip 6.3.3), and 6.4 (you can skip 6.4.2). Also, `Notes on Lists
and Iterators' in the content section of our ICON page.
- Lecture 1: Hash functions
- Lecture 2: Collision handling by separate chaining and by linear probing. Application of hash tables to the problem of detecting duplicates in an integer array.
- Lecture 3: Trees, notions associated with trees, the Tree interface, and how to use it to compute the depth of a node in a tree.
- Reading assignment: Sections 9.1 and 9.2.
- Lecture 1: Using the Tree interface to compute the height of a tree. to traverse it pre- and post- order. Applications of these traversals. A discussion of how the Tree and BinaryTree interface might be implemented.
- Lecture 2: Second Mid-term.
- Lecture 3: How to traverse it pre- and post- order. Applications of these traversals. A discussion of how the Tree and BinaryTree interface might be implemented.
- Reading assignment: Chapter 7. Certain parts of the chapter were only briefly discussed in the lectures, and certain parts were omitted.
- Lecture 1: Representing binary trees using arrays. Discussion of solutions
to some problems from Midterm 2. Introducing the priority queue ADT from Chapter 8.
- Lecture 2: Heap implementation of priority queue ADT.
- Lecture 3: Programming the heap implementation: insertion
- Reading: Chapter 8. Our heap-based Priority Queue Implementation
is different from the book's, and can be found in Homework 9.
- Lecture 1: Programming the heap implementation: removeMin.
- Lecture 2: Adaptable priority queues and Homework 9.
- Lecture 3: Binary Search Trees
- Reading: Adaptable priority queues from Chapter 8.
- Lecture 1: Implementation of elements of the Ordered Map ADT
using a binary search tree. Ours is different from the book's
in 10.1, though it follows the same ideas. Our implementation
can be found in Homework 10, where you will build on it.
- Lecture 2: Completing the implementation, and Homework 10.
Introduction to AVL trees.
- Lecture 3: Height of AVL trees. Restoring the AVL property after
an insertion: Part 1.
- Reading: Sections 10.1 and 10.2
- Lecture 1: Restoring the AVL property after an insertion: Part 2.
Extra topic not in the exam: k-d trees.