Binary Trees

Chapter 10

Introduction

• Previous chapter considered linked lists– nodes connected by two or more links

• We seek to organize data in a linked structure such that– it can be searched more efficiently– it can be used in new ways

• We begin with a review of search algorithms

Linear Search

• Collection of data items to be searched is organized in a list x1, x2, … xn

– Assume = = and < operators defined for the type

• Linear search begins with item 1– continue through the list until target found– or reach end of list

Linear Search

Vector based search functiontemplate <typename t>void LinearSearch (const vector<t> &v, const t &item, boolean &found, int &loc){ found = false; loc = 0; for ( ; ; ){ if (found || loc == v.size()) return; if (item == x[loc]) found = true; else loc++; }}

Linear Search

Singly-linked list based search functiontemplate <typename t>void LinearSearch (NodePointer first, const t &item, boolean &found, int &loc){ found = false; locptr = first; for ( ; ; ){ if (found || locptr ==) return; if (item == locptr->data) found = true; else loc++; }}

In both cases, the worst case computing

time is still O(n)

In both cases, the worst case computing

time is still O(n)

Binary SearchBinary search function for vector

template <typename t>void LinearSearch (const vector<t> &v, const t &item, boolean &found, int &loc)

{ found = false; int first = 0; last – v.size() - 1; for ( ; ; ){ if (found || first > last) return; loc = (first + last) / 2; if (item < v[loc]) last = loc + 1; else if (item > v[loc]) first = loc + 1; else /* item == v[loc] */ found = true; }

}

Binary Search

• Usually outperforms a linear search

• Disadvantage:– Requires a sequential storage– Not appropriate for linked lists (Why?)

• It is possible to use a linked structure which can be searched in a binary-like manner

Binary Search Tree

• Consider the following ordered list of integers

1. Examine middle element

2. Examine left, right sublist (maintain pointers)

3. (Recursively) examine left, right sublists

80666249352813

Binary Search Tree

• Redraw the previous structure so that it has a treelike shape – a binary tree

80

66

62

49

35

28

13

Trees

• A data structure which consists of – a finite set of elements called nodes or

vertices– a finite set of directed arcs which connect the

nodes

• If the tree is nonempty– one of the nodes (the root) has no incoming

arc– every other node can be reached by following

a unique sequence of consecutive arcs

Trees

80

66

62

49

35

28

13 70

Root node

• Children of the parent (66)

• Siblings to each other

Leaf nodes

Binary Trees

• Each node has at most two children• Useful in modeling processes where

– a comparison or experiment has exactly two possible outcomes

– the test is performed repeatedly

• Example– multiple coin tosses– encoding/decoding messages in dots and

dashes such as Mores code

Array Representation of Binary Trees

• Store the ith node in the ith location of the array

• Works OK for complete trees, not for sparse trees

U

T

P

O

E

M

C

0

1 2

3 4 5 6

Linked Representation of Binary Trees

• Uses space more efficiently

• Provides additional flexibility

• Each node has two links– one to the left child of the node– one to the right child of the node– if no child node exists for a node, the link is

set to NULL

data

left right

left child

right child

ADT Binary Search Tree (BST)

• Collection of Data Elements– binary tree– each node x,

• value in left child of x value in x in right child of x

• Basic operations– Construct an empty BST– Determine if BST is empty– Search BST for given item

ADT Binary Search Tree (BST)

• Basic operations (ctd)– Insert a new item in the BST

• Maintain the BST property

– Delete an item from the BST• Maintain the BST property

– Traverse the BST• Visit each node exactly once• The inorder traversal must visit the values in

the nodes in ascending order

BST Class Template

template <typename t>class BST{ private: /* Node structure */

class BinNode{ public:

t data;BinNode *left, *right;BinNode() { left = right = 0; }BinNode (t item) { data = item; left = right = 0; }

}; // end of class BinNode// ctd ->

BST Class Template

. . .

typedef BinNode *BinNodePointer;

public: // for BST

BST(); // construct an empty BST

bool Empty() const;

private:

BinNodePointer root;

}; // end of class template declaration

BST Class Template

• Definition of constructortemplate <typename t>BST <t>::BST()

{ root = 0; }

• Definition of Empty()template <typename t>

bool BST<t>::Empty(){ return root == 0; }

Searching a BST

template <typename t>bool BST <t>::Search(const t &item) const{ BinNodePointer locptr = root;

bool found = false;for ( ; ; ){ if found || locptr == 0) break; if (item < locptr->data) locptr = locptr->left; // descend left

else if (item > locptr->data) locptr = locptr->right; // descend right

else found = true;}

return found;}

Reached a leaf node without finding a match

Reached a leaf node without finding a match

Inserting an Item into a BST

template <typename t>

void BST<t>::Insert (const t &item)

{ BinNodePointer locptr = root; parent =0;bool found = false;for ( ; ; )

{ if found || locptr == 0) break; if (item < locptr->data) locptr = locptr->left; // descend left

else if (item > locptr->data) locptr = locptr->right; // descend right

else found = true;}if (found) cerr << "Item already in the tree\n"; . . .

Inserting an Item into a BST

else

{ locptr = new BinNode (item); // construct node containing item

if (parent == 0) // empty tree root = locptr; else if (item < parent->data) // insert left of parent parent->left = locptr else // insert right of parent parent->right = locptr;

} // end of the else

} end of the Insert

Problem of Lopsidedness

• Tree can be balanced– each node except leaves has exactly 2 child

nodes

• Trees can be unbalanced– not all nodes have exactly 2 child nodes

• Trees can be totally lopsided– each node has a right child only– degenerates into a linked list

Problem of Lopsidedness

• Balanced tree search has O(log2n)– best case

• Tree degenerated into linked list has search O(n)– worst case

• Other unbalanced trees somewhere in between• In general

– Not possible to predict how to insert to create balanced tree

– May require rebalancing algorithm

Binary Trees as Recursive Data Structures

• A binary tree is either empty …

or

• Consists of– a node called the root– root has pointers to two

disjoint binary (sub)trees called …• right (sub)tree• left (sub)tree

AnchorAnchor

Inductive step

Inductive step

Which is either empty … or …

Which is either empty … or …

Which is either empty … or …

Which is either empty … or …

Tree Traversal is Recursive

If the binary tree is empty thendo nothing

Else L: Traverse the left subtreeN: Visit the rootR: Traverse the right subtree

The "anchor"

The inductive step

Traversal Order

Three possibilities for inductive step …• Left subtree, Node, Right subtree

the inorder traversal

• Node, Left subtree, Right subtreethe preorder traversal

• Left subtree, Right subtree, Nodethe postorder traversal

Traversal Order• Given expression

A – B * C + D• Represent each operand as

– the child of a parent node– representing the corresponding operator

+

- D

A *

B C

Traversal Order

• Inorder traversal produces infix expression A – B * C + D

• Preorder traversal produces the prefix expression + - A * B C D

• Postorder traversal produces the postfix or RPN expression A B C * - D +

Traversing a Binary Tree

template <typename t>void BST<t>::Inorder(ostream &out){ InorderAux (out, root); }

template <typename t>void BST<t>::InorderAux (ostream& out,

BinNodePointer ptr){ if (ptr != 0)

{ InorderAux (opt, ptr->left); out << ptr-> data << " "; InorderAux(out, ptr->right);}

}

Two functions needed:

• We can send a message to a BST object … but …

• Cannot send a message to its root, required by recursion

•Inorder sends message to the root

Two functions needed:

• We can send a message to a BST object … but …

• Cannot send a message to its root, required by recursion

•Inorder sends message to the root

Change order of these three statements for different traversals

Change order of these three statements for different traversals

Recursive Searching

template <typename t>bool BST<t>::Search (const t &item){ SearchAux (root, item); }

template <typename t>void BST<t>::SearchAux (BinNodePointer locptr,

const t &item){ if (locptr == 0) return false; // empty tree if (item < locptr->data)

SearchAux(locptr->left, item);else if (item > locptr->data)

SearchAux (locptr->right, item);else return true;

}

Author suggests iterative approach is easier, just as efficient

Author suggests iterative approach is easier, just as efficient

Recursive Insertion

template <typename t>bool BST<t>::Insert (const t &item){ InsertAux (root, item); }

template (typename t>void BST<t>::InsertAux (BinNodePointer locptr,

const t &item){ if (locptr == 0) root = new BSTNode (item); else if (item < locptr->data)

InsertAux (locptr->left, item);else if (item > locptr->data)

InsertAux (locptr->right, item);else cerr << "Item already in tree\n";

}

Recursive Deletion

Three possible cases to delete a node, x, from a BST

• The node, x, is a leaf

• x has one child

• x has two children

• Note the source code for the deletion function, pgs 548 - 550