236 ===========================================================================
CSC Homework Assignment 3 Winter 2008
===========================================================================
Due: by 10am on Thu 3 Apr
Worth: 8%
For each question, please write your answer carefully. Keep in mind that
approximately half of the marks for each question will be given purely for
having the correct proof structure, written up clearly and precisely,
irrespective of the correctness of the proof. Also, make sure that you use
notation and terminology correctly, and that you explain and justify what
you are doing -- marks *will* be deducted for incorrect or ambiguous use of
notation and terminology, and for making incorrect, unjustified, ambiguous,
or vague claims in your solutions.
1. Reminders:
- In a Binary Search Tree (BST), every node stores a value with the
property that each node's value is greater than or equal to all the
values in the node's left subtree and less than or equal to all the
values in the node's right subtree. For this question, assume that
no two values are the same, i.e., each value is different from all
the others -- this is not strictly necessary for the code below to
be correct, but it makes the statement of correctness and its proof
easier.
- In Python (including the "pseudo-code Python" I use in the course),
it is possible to test if a reference is "null" by using it as a
truth value, e.g., the expression 'node.left' in a boolean context
(when evaluating an if-statement or while-statement) is considered
True if 'node.left' exists, and False if 'node.left' does not exist
(i.e., if 'node.left' is the special value None; the Python version
of "null").
Also, the keyword 'is' compares that two references actually refer
to the same object, e.g., 'node is node.parent.right' has value
True when 'node' is its parent's right child, False otherwise.
Prove that the following algorithm is correct, including filling in
appropriate loop invariants where indicated.
# Precond: 'node' is a reference to the root of a non-empty BST where each
# node stores a numerical value (in field 'datum'), in addition to
# references to its 'parent', 'left' child, and 'right' child. Also,
# every value in the tree is unique (does not appear more than once).
count = 0
average = 0.0
# LI^1: The subtree rooted at 'node' contains the smallest value in the
# entire tree.
node.left: while node = node.left
# LI^2: 'average' stores the average of every value in the tree that is
# strictly less than 'node.datum' (or the average of every value in
# the tree if 'node' is None).
while node:
count += 1
average += (node.datum - average) / count
# Let 'current' denote the value just added to the average
# (i.e., 'current' = 'node.datum' for the current node).
if node.right:
node = node.right
# LI^3: (TO BE FILLED IN: state the relationship between 'current'
# and values in the subtree rooted at 'node'.)
while node.left: node = node.left
else:
# LI^4: (TO BE FILLED IN: state the relationship between 'current'
# and values in the subtree rooted at 'node'.)
while node.parent and node is node.parent.right: node = node.parent
node = node.parent
# Hint: state the relationship between 'current' and 'node.datum' for
# the value of 'node' at this point.
# Postcond: 'average' stores the average of every value in the tree.
2. Give a NFA and a DFA for the following language, and justify that both
are correct (i.e., you do not have to write a complete proof of
correctness, but you should describe clearly the meaning of each state,
or show your work if you use a construction given in class).
{ w (- {-,0,1}* : **|w| >= 3 and**
the third-last character of w is not 0 }
(Where "third-last" is counted from the right.)
3. ...