CSS 343: Notes from Lecture 4 (DRAFT)

Administrivia

• assigment 1 revised due date: Oct 17, 2013
• next hackathon: assignment 1 (cont.): Sunday PM in the Linux Lab
• notes from Thursday night hackathon:
  • took longer than expected: too much talking
  • code produced was a first draft
    • needs commenting
    • needs second pass to refactor for readability
    polishing left as an exercise
  • the code was not initially bug-free (had to take a couple of quick iterations to fix small problems)
  • the code was a total of 111 lines, of which, the core functionality insert_word() was 32 lines
    • much easier to get working than the full 800-line final program
  • identify software ownership/authorship when you submit code
    • failure to do so is called plagiarism in academia; lawsuit in industry
    • the code is used by permission
    • you may claim co-authorship of code that you modify substantially
• wordcount implemented using std::map is a total of 21 lines (including 3 blank lines and 4 lines of boilerplate comment)

Our Story So Far

• algorithms: performance
  • asymptotic complexity: big-oh notation
  • complexity of an algorithm vs. complexity of the problem (best possible performance of an algorithm)
    • example: exponential vs. linear-time Fibonacci function
    • example: O(N2) vs. O(N log N) sorting
• cognitive complexity:
  • abstraction
  • mental gymnastics to traverse abstraction levels
  • C++ abstraction: declaration vs. definition
    • declaration (interface) in .h file; definition in .cc file
    • in practice, implementation details leak into header file
• preprocessor: 3 basic functions (plus some other less important stuff)
  1. #include
  2. #if
  3. #define
  • #define macros have become less important due to C++ const and inline
• undefined behavior: anything can happen (nasal demons)
  • stack smash attack takes advantage of specific knowledge of a particular implementation
• pointers & memory management
  • pointers to pointers
  • pointer arithmetic & arrays
• casting: escaping out of the type system
  • C++ style casting: 4 kinds
• sequential & random access to data
• dictionaries
• binary search & binary trees
• balanced binary trees (preview)

We've covered a lot of ground so far!

Tree Balancing Techniques: 2-3 Tree

• special case of B tree
  • O(log N) insert/lookup/delete time
• similar to BST (Binary Search Tree), except each node holds 1 or 2 keys, with 2 or three children for non-leaf nodes.
• invariant: all leaf nodes are at the same depth
• insertion:
  • find leaf node and add key if there is room
  • otherwise, split leaf and move middle of 3 keys to parent node (and repeat until overflow key fits into its parent node)
  • merging into the parent node occurs on return from the recursive call to child insert
• deletion: similar
• avoid confusing yourself with the exposition in the Carrano book: you cannot fit a third key into a 2-3 key node; for presentation purposes, it works "as-if" you did it that way as an intermediate step
• 2-3-4 trees: up to three keys in a node
  • interesting because it is isomorphic (identical structure) to red-black tree

Example: 2-3 Tree construction (click on image to enlarge) or download frame-by-frame zip.

Sample code: wordcount-btree.cc.

Compare the core node insert function as a single monolithic function versus broken up into sub-functions

// Copyright 2013 Systems Deployment, LLC
// Author: Morris Bernstein (morris@systems-deployment.com)

// META: here is the node insert function written as a single 106-line
// monolithic function.  The helper functions were simply folded
// in. Isn't this much harder to follow along?  Makes your brain hurt?
template<typename Thing>
typename BTree<Thing>::Node* BTree<Thing>::Node::insert(Thing* data, Thing** found) {
  if (is_leaf()) {
    if (data2_) {
      if (*data < *data1_) {
        Node* new_sibling = new Node(data);
        Node* new_root = new Node(data1_, new_sibling, this);
        data1_ = data2_;
        data2_ = NULL;
        *found = data;
        return new_root;
      } else if ((*data1_ < *data) && (*data < *data2_)) {
        Node* new_sibling = new Node(data2_);
        data2_ = NULL;
        Node* new_root = new Node(data, this, new_sibling);
        *found = data;
        return new_root;
      } else if (*data2_ < *data) {
        Node* new_sibling = new Node(data);
        Node* new_root = new Node(data2_, this, new_sibling);
        data2_ = NULL;
        *found = data;
        return new_root;
      } else if (*data1_ < *data) {
        *found = data2_;
        return NULL;
      } else {
        *found = data1_;
        return NULL;
      }
    } else {
      if (*data < *data1_) {
        data2_ = data1_;
        data1_ = data;
        *found = data;
      } else if (*data1_ < *data) {
        data2_ = data;
        *found = data;
      } else {
        *found = data1_;
      }
      return NULL;
    }
  } else if (*data < *data1_) {
    Node* overflow = left_->insert(data, found);
    if (overflow) {
      if (data2_) {
        Node* new_root = new Node(data1_, overflow, this);
        data1_ = data2_;
        data2_ = NULL;
        left_ = middle_;
        middle_ = right_;
        right_ = NULL;
        return new_root;
      } else {
        data2_ = data1_;
        data1_ = overflow->data1_;
        right_ = middle_;
        middle_ = overflow->middle_;
        left_ = overflow->left_;
        delete overflow;
        return NULL;
      }
    } else {
      return NULL;
    }
  } else if (*data1_ < *data && (!data2_ || *data < *data2_)) {
    Node* overflow = middle_->insert(data, found);
    if (overflow) {
      if (data2_) {
        Node* new_sibling = new Node(data2_, overflow->middle_, right_);
        data2_ = NULL;
        right_ = NULL;
        middle_ = overflow->left_;
        overflow->left_ = this;
        overflow->middle_ = new_sibling;
        return overflow;
      } else {
        data2_ = overflow->data1_;
        middle_ = overflow->left_;
        right_ = overflow->middle_;
        delete overflow;
        return NULL;
      }
    } else {
      return NULL;
    }
  } else if (data2_ && *data2_ < *data) {
    Node* overflow = right_->insert(data, found);
    if (overflow) {
      Node* new_root = new Node(data2_, this, overflow);
      data2_ = NULL;
      right_ = NULL;
      return new_root;
    } else {
      return NULL;
    }
  } else if (*data1_ < *data) {
    *found = data2_;
    return NULL;
  } else {
    *found = data1_;
    return NULL;
  }
}
        

// Copyright 2013 Systems Deployment, LLC
// Author: Morris Bernstein (morris@systems-deployment.com)

template<typename Thing>
typename BTree<Thing>::Node* BTree<Thing>::Node::insert(Thing* data, Thing** found) {
  if (is_leaf()) {
    return insert_leaf(data, found);
  } else if (*data < *data1_) {
    return insert_left(data, found);
  } else if (*data1_ < *data && (!data2_ || *data < *data2_)) {
    return insert_middle(data, found);
  } else if (data2_ && *data2_ < *data) {
    return insert_right(data, found);
  } else if (*data1_ < *data) {
    *found = data2_;
    return NULL;
  } else {
    *found = data1_;
    return NULL;
  }
}
        

B Tree

• generalization of 2-3 tree
  • node holds k keys
  • each node is at least half-full (except possibly the root)