Stanford introduction

    This [the following section until marked as end of Stanford University items] is article #110 in the Stanford CS Education Library. This and other free CS materials are available at the library (http://cslibrary.stanford.edu/). That people seeking education should have the opportunity to find it. This article may be used, reproduced, excerpted, or sold so long as this paragraph is clearly reproduced. Copyright 2000-2001, Nick Parlante, nick.parlante@cs.stanford.edu. [Stanford items are marked by a very light Stanford cardinal background.]

Typical Binary Tree Code in C/C++

    {NOTE; the original Stanford document separated the C/C++ and the Java discusssions. The material is interwoven here because this book uses the approach of teaching abasic concept and then showing it in multiple languages.]

    As an introduction, we’ll look at the code for the two most basic binary search tree operations -- lookup() and insert(). The code here works for C or C++. Java programers can read the discussion here, and then look at the Java versions.

    In C or C++, the binary tree is built with a node type like this…

struct node {
    int data;
    struct node* left;
    struct node* right;

}

lokkup()

    Given a binary search tree and a “target” value, search the tree to see if it contains the target. The basic pattern of the lookup() code occurs in many recursive tree algorithms: deal with the base case where the tree is empty, deal with the current node, and then use recursion to deal with the subtrees. If the tree is a binary search tree, there is often some sort of less-than test on the node to decide if the recursion should go left or right.

/*
 Given a binary tree, return true if a node
 with the target data is found in the tree. Recurs
 down the tree, chooses the left or right
 branch by comparing the target to each node.
*/
static int lookup(struct node* node, int target) {
  // 1. Base case == empty tree
  // in that case, the target is not found so return false
  if (node == NULL) {
    return(false);
  }
  else {
    // 2. see if found here
    if (target == node->data) return(true);
    else {
      // 3. otherwise recur down the correct subtree
      if (target < node->data) return(lookup(node->left, target));
      else return(lookup(node->right, target)); }
    }
  }
}

    The lookup() algorithm could be written as a while-loop that iterates down the tree. Our version uses recursion to help prepare you for the problems below that require recursion.

copyright notice

    This [the quoted passages above] is article #110 in the Stanford CS Education Library. This and other free CS materials are available at the library (http://cslibrary.stanford.edu/). That people seeking education should have the opportunity to find it. This article may be used, reproduced, excerpted, or sold so long as this paragraph is clearly reproduced. Copyright 2000-2001, Nick Parlante, nick.parlante@cs.stanford.edu. [Stanford items are marked by a very light Stanford cardinal background.]

    {NOTE; the original Stanford document separated the C/C++ and the Java discusssions. The material is interwoven here because this book uses the approach of teaching abasic concept and then showing it in multiple languages.]

end of Stanford introduction