Week 1

• 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 Homework 1.
• 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.

Week 2

• Lecture 1: An introduction to inheritence and polymorphism via this program.
• 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 recommended.

Week 3

• 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.

Week 4

• 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.

Week 5

• Lecture 1: We'll introduce the idea of primitive operations and running time analysis by looking at this Multiset Class .
• 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.

Week 6

• Lecture 1: Element Uniqueness - exponential, quadratic, and sorting-based solutions from Section 4.2.
• 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).

Week 7

• 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.

Week 8

• 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 next homework. 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.

Week 9

• 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.

Week 10

• 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.

Week 11

• 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.

Week 12

• 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.

Week 13

• 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.

Week 14

• 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

Week 15

• Lecture 1: Restoring the AVL property after an insertion: Part 2. Extra topic not in the exam: k-d trees.