CSS 343: Data Structures and Algorithms

Assignment 2

do not implement a general B Tree, just a 2-3 tree, which is a particular kind of B Tree

do not use parent pointer: use recursive algorithm

if you're stuck, implement a non-template version, then convert to template after it works

need to pass a pointer-to-pointer parameter in node insert function to return data [or make 2 pases internally for locate and insert]

std::map uses std::pair

our BTree requires the application program to provide the equivalent functionality

counter class is part of the assignment

you may implement your own
you may implement your own
the purpose is to demonstrate test coverage

a template needs to be in a .h file

a template does not define a class; it defines a class generator
a second-level #include as a good practice (not required for the assignment), but please do not call the second-level "btree.cpp"; a far, far better choice is "btree-impl.h"
walk needs to be a template function
a function object is simply an object that is a member of a class that implements operator()
not required for the assignment, but one person suggested writing self-checking code that will verify that all leaves have the same depth

Our Story So Far

BST mimics Binary Search

root is at midpoint
geared toward random selection

Priority Queue (Heap data structure) is a binary tree, but is not a BST

root is minimum element
geared toward random insert, remove minimum element
O(log N) insert (insert at bottommost leftmost free leaf and sift/bubble up)
O(log N) remove-min (replace root with bottom-most rightmost filled leaf and sift/bubble down)
priority queue invariant: any node is less than its children
heapsort O(N log N) is just selection sort O(N**2) with faster select-min operation O(log N)

Priority Queues (continued)

priority queue algorithm is optimal (proof: an asymptotically faster algorithm would imply a faster than O(N log N) sorting algorithm)

enumerating binary tree nodes: pre-order, in-order, & post-order (recursive algorithms)

any recursive algorithm can be implemented non-recursively using a stack
recursion uses a stack that is managed for you by the compiler

sample non-recursive in-order traversal:


			  node = root
while node or stack not empty
  while node
    push(node)
    node = node->left
  node = pop()
  process(node)
  node = node->right

compare with equivalent recursive traversal:


			  function inorder(node)
  if node->left
    node->left->inorder()
  process(node)
  if node->right
    node->right->inorder()
root->inorder()

numbering nodes in a binary tree top-to-bottom left-to-right order: breadth-first ordering breadth-first numbering

breadth-first ordering uses a queue instead of a stack

a priority queue (heap) is a complete binary tree, so we can order the nodes using a zero-bit for a left branch and a one-bit for right branch (need to start with most significant bit and work down to least-significant)

we can tell where to insert the next leaf node from the node count

This gives an even better way to represent a complete binary tree: use an array (or vector):

parent = node / 2
left_child = 2 * node
right_child = 2 * node + 1

Huffman Coding

Switching tack, this is not a complete non sequitur

Huffman is used in gzip

Huffman is an example of a greedy algorithm

locally optimal choices
also known as hill-climbing strategy
may not always yield an optimum solution—depends on the problem
typically proven by induction (recursion)

basic idea is to use a variable-length code

fewer bits for more frequently-occuring symbols
more bits for less-frequently-occuring symbols

prefix code: no coded symbol is the prefix of another symbol

poor name, but we're stuck with it

optimal code is a full binary tree

every non-leaf node has two children
full binary tree is not the same as a complete tree (although some particular tree may be both)

for each character c in alphabet, f(c) is the frequency d(c) is the tree depth (also: number of bits in encoding)

total number of bits to encode message: sum of f(c) * d(c) for every character c

solution: select two least-frequently occurring symbols and replace with a synthetic symbol with frequency equal to the sum of the frequencies of the two children synthetic character

iterate the greedy selection of lowest-frequency symbols using a priority queue (Ha! told you it wasn't a non sequiteur)

character code is based on tree traversal to leaf (left branch is zero-bit, right branch is one-bit))

for ASCII (8-bit data), we can use a 256-element array to hold character coding

decoding requires tree traversal

sample coding for a particular text (click on image for larger view):

CSS 343: Notes from Lecture 7 (DRAFT)

Administrivia

Assignment 2

Our Story So Far

Priority Queues (continued)

Huffman Coding