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

6.3.1 Binary Tree ADT

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

6.3.2 A Binary Tree Interface

• BinaryTree.cpp

6.3.3 Properties of Binary Trees

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

6.4.1 A Vector-Based Structure for Binary Trees

6.4.2 A Linked Structure for Binary Trees

• A node is represented by an object storing
• element
• link to the parent node
• link to the left child node
• link to the right child node
• Node objects implement the Position ADT

• void expandExternal(const Position& v)
• Position removeAboveExternal(const Position& v)   

6.4.3 A Linked Structure for General Trees

• A node is represented by an object storing
• element
• link to the parent node
• sequence of links to the children nodes
• Node objects implement the Position ADT

6.4.4 Representing General Trees with Binary Trees

• 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' is 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 '.