Day 
Read before
9:00 pm 
Reading
Assignment 
Pages 
1 
Monday January 24 
Preface 1.1 Structures and Section 9.1 of your best friend 2.1 What is Recursion? (Review) 5.1 The Stack 5.2 Application: Parenthesis Checker 5.3 Stack Implementation: Static Array 
ix  xi 13 2933 103104 104110 110113 
2 
Tuesday January 25 
The Perils of Java Schools 1.2 Unions and Section 9.8 from your best friend 2.2 The Towers of Hanoi 
16 34 3335 
3 
Wednesday January 26 
1.3 Enumerated Types 2.3 Fibonacci Numbers 
45 3536 
4 
Thursday January 27 
1.4 Function Invocation 5.4 Application: Graphical Region Fill 5.5 Stack Implementation: Dynamic Arrays 
59 113121 121123 
5 
Friday January 28 
1.5 Pointers ( partial: Intro ) 8.3.2 Mergesort 
1014 340345 
6 
Saturday January 29 
1.5.1 Using Pointers to Return
Values 4.1 List Concepts 4.2 Linked Lists (partial: Intro, 4.2.1, 4.2.2, 4.2.3 ) 
1415 5456 5659 
7 
Sunday January 30 
1.5.2 Pointer and Arrays 4.2.4 Primitive Operations on Linked Lists 4.3.5 Additional List Primitive Operations 
1520 5965 7376 
8 
Monday January 31 
1.5.3 Pointers and Structures 4.3.1 Polynomial Addition Program Design 4.3.2 Polynomial Driver 
2021 6667 67 
9 
January 30 
1.5.4 Pointer Arithmetic 4.3.3 Polynomial Data Type Implementation 8.3.6 Radix Sorting 
2122 6872 357 
10 
January 31 
1.6 Pointers to Functions 4.3.4 List Interface Routines for Polynomials 7.1 Trees and Graph Concepts 
23 7273 238239 
11 
February 1 
1.7 Typedef 7.2 Binary Trees Intro 7.2.1 Traversing a Binary Tree 7.2.2 C Representation of Binary Trees 
2324 239240 240242 242243 
12 
February 2 
1.8 Dynamic Memory Allocation 7.2.3 Primitive Operations on Binary Trees Binary Search Trees 
2526 244248 328332 
13 
February 3 
5.8 The Queue 5.10 Queue Implementation: List Functions 3.1 Abstract Data Types 
135136 145146 3944 
14 
February 4 
6.1 Circular Lists Intro 3.2 Polymorphic Data Tyypes 
152153 4445 
15 
February 5 
6.1.1 Primitive Operations on
Circular Lists 3.3 Software Development and Life Cycle ( first part) 
153159 4546 
Homework1 
Homework2 
Homework3 
Homework4 
Homework5 
Homework6 
Homework7 
Homework8 
Homework9 
Homework10 
Homework11 
Homework12 
HomeworkA 
HomeworkB 
HomeworkC 

Homeworkgtk1 
Homeworkgtk2 
Ch 
Title 
Date 
Readings 
Study
Guide/Worksheet 
Homeworks 
Due Dates 
Old Exams +
Powerpoint Slides 
Other 
1 
Advanced C Constructs 
Should be done before class starts. 
Pages 126 
101 Programs 125 101 Programs 2630 101 Programs 3135 101 Programs 3640 101 Programs 4145 101 Programs 4650 101 Programs 5155 101 Programs 5660 101 Programs 6165 101 Programs 6670 101 Programs 7175 101 Programs 7680 101 Programs 8185 101 Programs 8690 101 Programs 9195 101 Programs 96101 
Monday, Feb. 1 Monday, Feb. 8 Monday, Feb. 15 Monday, Feb. 22 Monday, March 1 Monday, March 8 Friday, March 12 Monday, March 22 Monday, March 22 Monday, March 29 Monday, April 5 Monday, April 12 Monday, April 19 Monday, April 26 Monday, May 3rd Monday, May 10th 
Fall 2008 91.101 Computing Final  
2 
Recursive Functions 
Jan. 25 Jan. 25 Jan. 26 Jan. 26 
Section 2.1 (pp. 2933) Section 2.2 (pp. 3335) Section 2.3 (pp. 3536) Section 2.4 (pp. 3637) 
Study Guide and Worksheet 
Assignment 1 Assignment 2 Assignment 3 Assignment 4 

3 
Data Structures and Software
Development 
Section 3.1 Section 3.2 Section 3.3 Section 3.4 Section 3.5 
Study Guide and Worksheet 
Assignment
1 Assignment 2 Assignment 3 Assignment 4 
Chapter
3
Powerpoint Slides 1 Chapter 3 Test 

4 
Lists 
Section 4.1 Section 4.2 Section 4.3 Section 4.4 Section 4.5 
Study Guide and Worksheet 1 Study Guide and Worksheet 2 
Assignment 1 Assignment 2 Assignment 3 Assignment 4 
Chapter 4 Test Chapter 4 Test (2007) 

5 
Stacks and Queues 
Section 5.1 Section 5.2 Section 5.3 Section 5.4 Section 5.5 Section 5.6 Section 5.7 Section 5.8 Section 5.9 Section 5.10 Section 5.11 
Study Guide and Worksheet 1 Study Guide and Worksheet 2 
Stack 1 Parentheses Checker Fill 1 Fill 2 Fill 3 Fill 4 Infix to Postfix 1 Infix to Postfix 2 Queue 1 Oper. System Sim 1 Queue 2 Oper. System Sim 2 

6 
Advanced List Structures 
Section 6.1 Section 6.2 Section 6.3 Section 6.4 Section 6.7 
Assignment 1 Alligators and Ducks Lisp 1 Lisp 2 Lisp 3 Lisp 4 Doubly Linked Lists Simple Line Editor 1 
Chapter 6 Test  
7 
Trees and Graphs 
Section 7.1 Section 7.2 Section 7.3 Section 7.4 Section 7.5 Section 7.6 Section 7.7 Section 7.8 Section 7.9 Section 7.10 Section 7.11 Section 7.12 Section 7.14 
7.1
Assignment Expr. Eval A Expr. Eval B Expr. Eval C Graph Primitives AM 

8 
Sets, Searching, and Sorting 
Section 8.1 Section 8.2 Section 8.3 Section 8.4 
Bit Vector Assignment Poly. Mergesort Poly. Quicksort Poly. Heapsort Poly. Radix sort 

Other 
Task 
Description 
Due Date 
Comment 
Deliverable
to
Pass In? 

8 
Read section 8.1 in Esakov. 
Jan. 26 
Record how long it took you to
read it. Take notes. In your notes write down the title of section. In
your notes write down the formal definition of the Big Oh notation. As
you read the section, ask yourself "What would Jim ask me about
this section?" Write down possible questions that I would ask of you.
Thirty minutes spent now reading this section is time you will save
later. Try to get this done well before the start of classes. It is
always better to have read the material in the book before we discuss
it in class. 
No 

13 
Read the four introductory
paragraphs that start Section 8.2 
Jan. 26 
This is less than 1 full page of
material. You should take notes as you read it. Make sure you know the
title of Section 8.2. Make sure you know the exact title of your
textbook. Make sure you know the exact spelling of the names of the
textbook's two authors. 

16 
Read Subsection 8.2.1 
Now 
Subsection 8.2.1 is called
BitVector Representation. Know this title. What is the title of
Chapter 8? Who are the two authors of your textbook? This
subsection is just three pages full. As you read this section
doodle a picture of the data structure. What is the purpose of
the array called bit? Do you see exactly how a set of integer
values is being represented. This approach is a good approach
when you are keeping track of a finite set of integers or when your
data can be mapped easily into a finite set of integer values. 

17 
Bit Vector Representation 
TBA 
Remember
at
the tail end of Compuing I, I gave a copy of globals.h to you. You
were supposed to have typed it in. I hope you did. Make a copy of
globals.h and move it into your bitvector directory. For this
assignment you will also need to create set.h, set.c, and a makefile.
You will also need to create two data files. The full writeup for this
assignment can be found by clicking on the link to the left. This code
is not polymorphic. You need to do this assignment if you wish to become a Master of Chapter 8. There will be other such assignments. Get this one out of the way now. Spend 90 minutes now getting this to work. It is 90 minutes you will have when you need to study that math test or write that term paper. 
Yes 

19 
(re) submit paper copies of
problems 1120 of "Jim's Programming Problems" given in Computing I 

Yes 

20 
(re) submit your paper copy of
selection sort. This is the non polymorphic version. 
You should go back and review
this code. I beleive it was programming problem 79 from last semester.
Walk yourself through it. Take the time to do. Doodle how it works.
Make sure you can replicate this code without the aid of a textbook.
You should be able to write this program on a piece of paper with your
book closed and nobody looking over your shoulder. 
Yes 

23 
Extending
Problem
74 
On page
50 of your textBook, you will find problems 1a, 1b, and 1c. You need to
get these routines built and placed into your complex.c file. You will
also need to add their "declarations only" to your complex.h
file. 
Yes 

25 
Read Section 8.2.2 
You are on your way to becoming
Masters of Chapter 8. One step along this path is to fully understand
the material on pages 321, 322, 323, and the top half of page 324. Find
a quiet, well lit location, shut down your ipod, mp3 players, cell
phone, blackberry, radio, tv, and have a quiet moment with subsection
8.2.2. You can do this. 
No 

26 
Sequential
Set
Representation 
TBA 
Make
another copy of globals.h and move it into your sequential directory
within your ch8 directory. In addition to this you will need to obtain
my version of main.c for this problem. It can be found in my public
directory. You will also need to create set.h, set.c, and makefile. The
set.c file will contain the init_set function definition located on
page 322. Type this in. It will also contain both the set_insert and
set_member functions found on pages 322, 323, and 324. This representation of sets is polymorphic. It can be used to represent a set of integers, a set of words, a set of doubles, a set of sets, etc. It contains two key ideas. The first is the concept of a generic pointer. Generic pointers are pointers to a void. They are useful because their size is the same no matter what it is they point to. The second concept is passing a function as an argument. 
Yes 

31 
Read Section 5.2 
Now 
Read section 5.2 in its
entirety. Go someplace quiet. Turn off your electronic devices. This
section spans pages 104, 105, 106, 107, 108,109, and 110. As you read
this material, you should realize that the code given relies upon the
material discussed in section 5.3. You should also note that the switch
statement at the bottom of page 106, the top of page 107, and at
the top of page 108 contain errors. The '' symbol and the
" symbol are the wrong symbols. Never the less, you should mentally
trace through this code. 

33 
Create
stack.h, stack.c for the Parenthesis Checker Case Study. 
Using Section
5.3 as your guide create two files within your ch5/paren subdirectory.
One file is called stack.c and it contains the code for init_stack,
empty_stack, push, pop, and top. These function definitions are given
on pages 111 and 112. You can do this. You will need to include both
globals.h and stack.h. The second file is called stack.h. Use the
#ifndef construct and put an appropriate description comment at the top
of the files identifying who you are, the name of each file, and
incorporate the case study name too (parenthesis checker). After doing this you should be able to successfully compile the program. I did not say link the program. You need to use the c option on the gcc command line. For example, %gcc c ansi Wall stack.c. Ideally, you will have no error messages or warning messages. If you do, find a way to eliminate them. Make sure you understand the code that you are typing in. 
Not yet 

35 
Creating a stack interface
module for the parenthesis checker problem. 
Make sure you've completed tasks
29, 30, 31, 32, and 33. Now, you need to built interface.c and
interface.h for the parenthesis checker problem. The code for
interface.c is located on page 108 and page 109. This interface codes
sits between the main function and the stack primitives. The interface
code know that the stack primitives seeks generic pointers. The
interface code knows that the main routine will be passing down
(push_char) or expecting to receive (pop_char, top_char) character
data. The interface code repackages the data. The interface.c file will need to include interface.h and globals.h. At first, this code will look confusing to you. Try your best to doodle it out and walk yourself through it. I will go over this code in class. 
Not yet 

36 
Parenthesis
Checker 
Create
main.c for the parenthesis checker program. The code for this is in
your book on pages 106, 107, and 108. Type it in. Create a makefile for the parenthesis checker program. You can do this. Hand in a working paper copy of the parenthesis checker program to me. Put the makefile on top. Clearly label the makefile with a comment as to who you are and what the program name is. Electronically submit your working copy of the parenthesis checker as indicated in the table below. 
Yes 

37 
Selection Sort  the non
polymorphic version 
Go back and find your solution
to programming problem 79. This was the non polymorphic version of
selection sort. It sorted integers. Submit your paper copy of this
program. In so doing, you are verifying that it works and that you
understand it. 
Yes 

38 
Polymorphic
Selection
Sort of Strings 
At the
very bottom of page 338 and at the top of page 339 you will find code
for a polymorphic implementation of selection sort. It relies upon
generic pointers and C's ability to pass a function as an argument. You
should move into your 102/ch8/sorting directory and then create a
selection subdirectory. Move into the selection subdirectory and then create selection.h and selection.c.
The
code for selection.c is in the book. The code in the book is
correct. There are no typos. Within selection.c you will need to
include "globals.h". Make your code look good. Let it breathe. You are
not in a rush to complete it. The doodle in the book 2/3rds of the way
down page 339 is a bit misleading since it shows integer data within an
array of integers. This is not quite right. The doodle should be an
array of pointers (to voids). The authors did this, perhaps, to save
ink as the real doodle would have been a bit more complicated. They
simplified matters and hoped that you would know how the code works by
reading it. Your selection.h must have a header comment. Your selection.h must use the #ifndef construct. You will need to include "globals.h". You should compile this using the c option as well as the ansi and the Wall options. Ok, now you should create main1.c. it is given to you on the bottom of page 339 and the top of page 340. It is very short. Build an executable image and get your program to run. Submit yoru hard copy to me and also submit your code electronically. 
Yes 