\documentstyle{article}

\begin{document}

\section*{Lect 9: Sep 23}

\begin{enumerate}
\item Tree continued.
The binary search tree. In in-order property of a
search tree.
\item Representation of a tree:
\begin{verbatim}
  tree = ^ treerecord ;
  treerecord = record
       key : integer ;
       left, right : tree ;
       end;
\end{verbatim}
\item Searching in a tree. 
\item Insertion in a tree.
\item Traversing a tree. Pre, post and Inorder traversal. The
code for a stack pre-order traversal.
\item Bredth and Depth first search regimes.
\end{enumerate}

\section*{Lect 10: Sep 28}

\begin{enumerate}
\item Finish material in Sedgewick: representation of forests.
\item Inorder traversal.
\item Recursion.
\end{enumerate}

\section*{Lect 11: Sep 29}

\begin{enumerate}
\item Recursion: more examples, tail recursion,
  while loop and repeats done recursively.
  Recursion replaced with iteration and a stack.
\item Algorithmic analysis. Fundamental notions.
  Problem size and problem families.
  Average and worst case.
  Instruction counting and the inner loop.
  Complexity families,
\[ 1, log n, n, n log n, n^2, n^3, 2^n.\]
\end{enumerate}

\section*{Lect 12: Oct 5}

\begin{enumerate}
\item Big O notation. Rules and regulations.
\item Analysis of our homework run times using the big oh.
\end{enumerate}

\section*{Lect 13: Oct 7}

\begin{enumerate}
\item Sorting: Selction, Insert, Bubble, Shell,
  with some analysis.
\item Quick: worst, best and average case analysis.
\end{enumerate}

\section*{Lect 14: Oct 12}

\begin{enumerate}
\item Quick sort, last words.
\begin{enumerate}
\item Reduction in size of stack to $O(log n)$ in the worst case
\item Using insertion sort for the small recursive partitions
\end{enumerate}
\item Merge sort, using a linked list.
\item Heap sort, idea, ADT def. of a heap, using function map notation,
  and categorization of efficiency of operations.
\item Implementation of a heap in two ways using arrays, leading to
  $O(n)$ in either insert or deletemin. 
\end{enumerate}

\section*{Oct 14, Midterm.}

\section*{Lect 15: Oct 19}
\begin{enumerate}
\item Went over Midterm
\item Went over solution to Homework 6
 (as part of the solution to Homework 6)
  deletion in binary trees.
\end{enumerate}

\section*{Lect 16: Oct 21}

 Heaps, continued ...
  Heap order in trees, array based implementation
  How to insert and delete min, use in a sorting algorithm.

\section*{Lect 17: Oct 26 }

\begin{enumerate}
\item Linear time build of a heap, Analysis ... see notes
\item Bucket sort. Screwed this one up, need to be certain
  about numbers always going small to large as one scans
  any pile bottom to top. 
\item Balanced binary trees. 2-4 trees, and red-black trees.
\end{enumerate}

\section*{ Lect 18: Oct 28 }

\begin{enumerate}
\item 2-4 trees, red-black trees and splay trees. Discussion of
  homework 7.
\item
Notes: waters were muddied w/ 2-4 trees about Sedgewick's
notation for leaves (versus internal nodes).
Screwed this one up to, not remembering that values go
up into a parent, then forgetting which node to send up.

The rule is:
\begin{center}  middle value to parent \end{center}
when splitting 4 nodes.

This includes splitting the leaf, so there are no creations
during insert.

To note:
\begin{enumerate}
\item now 1-3 values, but no longer 1 child, 2-4 children.
\item  no creations during insert
\item  4 children (3 values) is unstable.
\end{enumerate}
\end{enumerate}


\section*{ Lect 19 : Nov 2}

\begin{enumerate}
\item
 Hashing, Open Chaining, Linear Probing and Double Hashing.
  Dynamic Rehashing.
  Here is a sample text, not taken from the class, but from an
  explanation to a certain student afterwards.

  Take a able of size 17 and a skip value of 4. Here is the sequence
  of table locations visited:
  \[ 0,4,8,12,16,3,7,11,15,2,6,10,14,1,5,9,13 \]
  Number 1 is the 13-th element on the list, and we subtracted 17 three
  times in the sequence of operations leading to 1. So:
   \[ 1 = 13*4 - 3*17. \]
  If $d | 4$ and $d| 17$ then it divides any linear comb, hence
  $ d | 1 \Rightarrow d=1.$
\end{enumerate}

\section*{Lect 20 : Nov 4 : off}

\section*{Lect 21 : Nov 9}
  Radix Search, Tries and Patricia trees. Real-life example:
  i-nodes in Unix (complements discussion of FAT table in DOS.)

\section*{Lect 22 : Nov 11}
 Knuth-Morris-Pratt and Rabin-Karp String matching.

\section*{Lect 23 : Nov 16}
  NDFA and regular expression
  matching, Sedgwick's book chap 20 ,
  Turing Machines, finite automata

\section*{Lect 25 : Nov 18}

Turing machines, introduction of
Homework 10, how to program a Turing machine.
\begin{enumerate}
\item
  Duplicating a string. Introduction of notation,
  $\Sigma^*, \Sigma^+, \alpha^n, \alpha\in\Sigma$. The
  method was to select a character outside the input
  language and to place two stars, *, one over the
  copy from character, one over the copy to position.
  And to chase back and forth from star to star.
\item
  Using $/xxxxxxx/$ to demark ``records''.
\end{enumerate}

\section*{Lect 26 : Nov 23}

 Introduction to extra homework assignment
  and description of shaker sort. The proof of its run time.
  In particular to proof that:
    In a poset on $n$ elements, there is either a chain of
    length $\sqrt{n}$ or an antichain of size $\sqrt{n}$.
  Including all the nec. def's (poset, incomparable, chain,
  antichain.)

\section*{Lect 27 : Nov 30 }
   Parsing and Context-Free Grammers, Chap 21 in Sedgewick's
 
\section*{Lect 28 : Dec 2}
   File compression, Run-length codes and Huffman codes
   Chap 22 of Sedgewick's.

\section*{Dec 14, Final exam}
\end{document}

