Note: I am now (December 9) finished adding sample problems to this review. Good luck on the exam!

Topics with Details:

• Simulation: (See Week 7 Notes.)
  • Time-driven, real-time, and event-driven simulations.
  • Example of time-driven simulation (traffic-light).
  • Examples of real-time simulations (flight simulators discussed in class).
  • Example of event-driven simulation (Recitation 6).
    • What are events?
    • How and why is a priority queue used?
    • What is the intuitive distribution of interarrival times?
    • What is an abstract class and how is it used?
    • What is a buffered router?

• Recursion: (See Week 9 Notes.)
  • Simple examples of recursion.
  • Use of recursion to cause output to come in opposite order (writebase function, encoding with Huffman code as in Recitation 11 -- each of these examples could be handled either with a stack or with Java's convenient string concatenation on the left).
  • Example where recursion doesn't work well (Fibonacci numbers, the recursive function is too inefficient).
  • Example where recursion helps a lot (inorder traversal of a binary tree).
    

  • Sample problem: A function with a recursive definition.
    Suppose a function C(n, k) is defined mathematically as follows (actually, C(n, k) is "the number of ways to take n things k at a time"):

    
          C(n, k) = 1, if k = 0 or if n = k
          C(n, k) = C(n-1, k) + C(n-1, k-1), otherwise.
    

    1. Write Java code to implement this function.
    2. Trace the tree of recursive calls that would be generated by calculating C(5, 3).
    3. Here are execution times for a few example calls of this function:

       
            C(1,  8): 1              Elapsed time: 0.0030 seconds
            C(16, 8): 12870          Elapsed time: 0.019 seconds
            C(24, 8): 735471         Elapsed time: 0.152 seconds
            C(32, 8): 10518300       Elapsed time: 1.314 seconds
            C(40, 8): 76904685       Elapsed time: 9.216 seconds
            C(48, 8): 377348994      Elapsed time: 48.292 seconds
            C(56, 8): 1420494075     Elapsed time: 198.57 seconds
            C(64, 8): (overflow)     Elapsed time: 662.561 seconds
       

       Do you have an explanation for the data above? A non-recursive implementation would do all the calculations in a small fraction of a second. Why is the recursive implementation not a reasonable one for the function?

• Linked Lists: (See Week 10 Notes.)
  • Simple linked list example with addFirst, removeFirst, and addLast. The reason why it is not reasonable to have a removeLast method.
  • Use of this kind of linked list to give a queue or a stack. (This is a completely different implementation from the array-based implementation.)
  • Simple extension to give a linked list of objects.
    

  • Sample problem: Printing Linked Lists.
    Consider the simple linked list of ints presented in class and in the notes: integer linked list, with corresponding listnode class: integer list node.
    1. How do you use this to give a stack of integers? Give sample calls to push integers 17 and then 46, and then to pop them off the stack.
    2. How do you use this to give a queue of integers? Give sample calls to add 17 and then 46 to the queue, and then to remove them.
    3. Write a non-recursive method to print the elements of the list (without altering the list).
    4. Write a recursive method to print the elements of the list. (Write a function that prints the first element, if it is not a null reference, and then calls itself recursively to print the node inside the node that first refers to.)

• Trees: (See Week 11 Notes.)
  • Binary trees, with emphasis on binary search trees. (These have a natural order (such as numeric or alphabetic) for the data at the nodes, and inorder for the tree is the same as this natural order.)
  • Simple examples, using strings and doubles.
  • More on binary trees in Project 3, including the idea of a level-order traversal of a binary tree.
    

  • Sample problem: Example Binary Search Tree.
    
    1. Construct the binary search tree obtained by inserting the following strings into the tree in inorder: one, two, three, four, five, six, seven, eight, nine, and ten.
    2. Give Java code for a recursive method that does an inorder traversal, printing each string in turn, to sort the numbers into alphabetic order.

• Sorting: Bubblesort, "Treesort, Quicksort: (See Week 12 Notes.)
  • "Big-oh" algorithm notation.
  • Simple bubble sort: a very poor O(n²) sort.
  • "Treesort: Use of a binary search tree along with an inorder traversal to give a high-performance sort method. (Poor performance for files that are already sorted.)
  • Quicksort: in class a simple version with average performance O(n log n), but worst-case performance O(n²) for a file that is already sorted.
  • Use of an initial quick O(n) randomization step to make the poor performance for a sorted file very unlikely.
    

  • Sample problem: Sorting.
    
    1. Explain why quicksort is so much faster than bubblesort, when both of them just interchange elements in an array.
    2. Explain how an initial randomization of an array of elements to be sorted can improve the preformance of some versions of quicksort or treesort. (Which cases cause trouble without the randomization step?)

• Huffman Code: (See Week 13 Notes.)
  • The process of gathering data about the frequency of characters in a file.
  • Given the prequencies, constructing the Huffman tree by hand.
  • Using the Huffman tree to do encoding/decoding by hand.
  • Representation method in Recitation 11, using an array of classes to represent the Huffman tree, including left and right child pointers, as well as a parent pointer. (These are not actual Java references, but are indexes in the array. It would be possible to do this recitation in a different way using actual Java references.)
    

  • Sample problem: Suppose there are symobls and numbers of bytes as follows: a:10, b:5, c:4, d:3, and e:3.
    
    1. Construct the Huffman tree by hand.
    2. In detail show how to use the tree to encode the symbols b d c.
    3. Show how to use the tree to decode the binary (encoded) string of bits that you got in the previous part.
    4. If one changes the number of bytes of a above to a:9, show that there will be two possible Huffman trees that have different structures, one with the same structure as before and a different one. (However, the Huffman code is always optimal, so we know that the average code length of the code given by each of these trees must be the same. In both cases the average code lenght is 36/24 = 1.5 bits per symbol.)

• Hashing: (See Week 14 Notes which just refer to work in class.)
  • The basic idea of hashing for strings, using a "magic" hash function, say int hash(String s) { ... } to provide an index for an array of strings.
  • Handling the situation where two string hash to the same value, known as a collision: Use either
    • Open addressing: store the second item in the next free location moving down (with wrap-around).
    • Bucketing: use a linked list of locations for all items that hash to a given index.
    • Sample hash functions. Even the function that always returns 0 will work, it just won't be any better than an unordered list.
    • Good hash functions. Must depend on every character. Want to spread the values out randomly among all the array index values.
    • Similarity of hash functions to functions used in other applications, such as checking file transmissions for errors, using a transmitted hash function value of the file.
      

    • Sample problem: Hashing.
      
      1. For both open addressing and bucketing, explain carefully why a hash function that always returns the index 0 will still work, but will lose the benefit of using hashing.

• Applets: (See Project 3, which does applets in its third part. There is also beginning material about applets in Recitation 12, which we did not do, but this can still serve as a resource.)
  • Basic form of a simple applet, as described in Project 3: extending the library Applet class, and using the paint method with the Graphics class as a parameter.
  • Actually painting lines and circles for Project 3.

Projects:

• Project 2: Applying a Dictionary of Changes to a File. A solution to this project is Here.
  • Reading from a separate file and writing to a separate file.
  • String processing.
  • Use of an array of classes, including insertion and lookup methods.

• Project 3: Binary Trees: Traversals and Drawing. A solution to this project will be supplied later.
  • Using a inorder traversal to calculate node numbers and depth of nodes.
  • Using an level-order traversal to calculate breadth numbers as well as depth.
  • Using the depth and node number of each node to actually draw the tree.

Recitations: See the List of Recitations. (New recitations after the mid-term exam are those below (we didn't do 12, although Project 3 has an applet).

• Recitation Exercise 6: A Queue Application - Studying Network Node Behavior Using Event-Driven Simulation
• Recitation Exercise 7: Instrumenting a Stack
• Recitation Exercise 8: Doubly-Linked List
• Recitation Exercise 9: Using Recursion to Traverse a Directory Tree
• Recitation Exercise 10: Animation of the Quicksort(Omit for Summer)
• Recitation Exercise 11: Huffman Encoding and Decoding of a File