Chapter 6. Trees II

6.3 Binary Trees

A binary tree is a tree with the following properties: Each internal node has two children The children of a node are an ordered pair We call the children of an internal node left child and right child Alternative recursive definition: a binary tree is either a tree consisting of a single node, or a tree whose root has an ordered pair of children, each of which is a binary tree

Binary tree associated with an arithmetic expression internal nodes: operators external nodes: operands Example: arithmetic expression tree for the expression (2 × (a −1) + (3 × b))

• Binary tree associated with a decision process
• internal nodes: questions with yes/no answer
• external nodes: decisions
• Example: dining decision

• The BinaryTree ADT extends the Tree ADT, i.e., it inherits all the methods of the Tree ADT
• Additional methods:
• Position leftChild(Position)
• Position rightChild(Position)
• Position sibling(Position)
• Update methods may be defined by data structures implementing the BinaryTree ADT

html-6.14a (InspectableBinaryTree)
html-6.14b (BinaryTree)

btree.cpp

We denote the set of all nodes of a binary tree T, at the same depth d, as the level d of T.

Proposition 6.9: Let T be a (proper) binary tree with n nodes and let h denote the height of T. Then T has the following properties:

1. The number of external nodes e in T is: h + 1 ≤ e ≤ 2^h
2. The number of internal nodes i in T is: h ≤ i ≤ 2^h − 1
3. The total number of nodes n in T is: 2h + 1 ≤ n ≤ 2^h+1 − 1
4. The height h of T is: log(n + 1) − 1 ≤ h ≤ (n − 1)/2

Notation n - number of nodes e - number of external nodes i - number of internal nodes h - height Properties: e = i + 1 n = 2e − 1 h ≤ i h ≤ (n − 1)/2 e ≤ 2h h ≥ log2e h ≥ log2(n + 1) − 1

void binaryPreorderPrint(const Tree& T, const Position& v) 
{ cout << v.element();		// print element
  if (isInternal(v))		// visit children
  {  cout << " ";
     binaryPreorderPrint(T, T.leftChild(v));
     binaryPreorderPrint(T, T.rightChild(v));
  }
}

void binaryPostorderPrint(const Tree& T, const Position& v) 
{ if (isInternal(v))    // visit children
  { cout << " ";
    binaryPostorderPrint(T, T.leftChild(v));
    binaryPostorderPrint(T, T.rightChild(v));
  }
  cout << v.element(); // print element
}

Specialization of a postorder traversal recursive method returning the value of a subtree when visiting an internal node, combine the values of the subtrees O(n) time algorithm

In an inorder traversal a node is visited after its left subtree and before its right subtree Application: draw a binary tree x(v) = inorder rank of v y(v) = depth of v Visit "left to right"

void binaryInorderPrint(const Tree& T, const Position& v) 
{ if (isInternal(v))        // visit left child
     binaryInorderPrint(T, T.leftChild(v));
  cout << v.element();      // print element
  if (isInternal(v))        // visit right child
     binaryInorderPrint(T, T.rightChild(v));
}

• the elements stored in the left subtree of v are less than or equal to e, and
• the elements stored in the right subtree of v are greater than or equal to e.

Position searchBinaryTree(const Tree& T, const Position& v, const Object& e)
{ if (isInternal(v))
    if (v.element() == e) return v;                 // found!
    else if (v.element() < e)
         searchBinaryTree(T, T.leftChild(v), e);    // search left subtree
    else searchBinaryTree(T, T.rightChild(v), e);   // search right subtree
  else return ...                                   // not found!
}

Generic traversal of a binary tree Includes a special cases the preorder, postorder and inorder traversals Walk around the tree and visit each node three times: on the left (preorder) from below (inorder) on the right (postorder)

6.4 Data Structures for Representing Trees

• If v is the root of T, then p(v) = 1.
• If v is the left child of node u, then p(v) = 2 p(u).
• If v is the right child of node u, then p(v) = 2 p(u) + 1.

• A node is represented by an object storing
• Element
• Parent node
• Left child node
• Right child node
• Node objects implement the Position ADT

• A node is represented by an object storing
• Element
• Parent node
• Sequence of children nodes
• Node objects implement the Position ADT

• For each node u of T, there is an internal node u' of T ' associated with it.
• If u is an external node of T and does not have a sibling immediately following it, then the children of u' are external nodes.
• If u is an internal node of T and v is the first child of u in T, then v' if the left child of u' in T '.
• If node v has a sibling w immediately following it, then w' is the right child of v' in T '.