Embed Size (px)
Citation preview
1
Binary Search Trees
Chapter 6
2
Objectives
You will be able to Implement and use binary search
trees in C++ programs. Determine the time complexity of
searching binary search trees.
3
Searching
We often need to find a specific item in a collection of items. Or determine that it is not present.
The simplest strategy is a linear search. Traverse the collection looking for the
target item. Time for a linear search is O(n).
Grows in proportion to the number of items in the collection, n.
4
Binary Search
If an array is ordered, we can make the search much faster by doing a binary search.
If length of the array is 0, Search target is not present. Report failure.
Check the middle item. If search target is equal
Return that item. If the search target is less:
Do a binary search of the lower half. If the search target greater
Do a binary search of the upper half.
5
Binary Search
Usually outperforms a linear search Disadvantage:
Requires a sequential storage Not appropriate for linked lists (Why?)
A linked structure is desirable if we do very much inserting and deleting.
It is possible to use a linked structure which can be searched in a binary-like manner.
6
Binary Search Tree
Everything in left subtree is less than root. Everything in right subtree is greater than root.
Recursively!
49
80
62
35
13
66
28
7
Tree
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 starting at the root.
8
Tree Terminology
Root nodeRoot node
Leaf nodesLeaf nodes
• Children of the parent (3)
• Siblings to each other
• Children of the parent (3)
• Siblings to each other
9
Binary Tree
Each node has at most two children
Examples Results of multiple coin tosses Encoding/decoding messages in dots
and dashes such as Morse code
Implementation
A binary tree ADT can be implemented either as a linked structure or as an array.
10
11
Array Implementation of Binary Trees
Store node n in location n of the array.
O
UPEC
TM
0
21
6543
12
Array Implementation of Binary Trees
Works OK for complete trees, not for sparse trees
13
Linked Implementation of Binary Trees
Uses space more efficiently for incomplete trees
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
14
Structural Recursion
O
UPEC
TM
0
21
6543
The subset of a binary tree consisting of any node an all of its descendents is a binary tree.
Invites the use of recursive algorithms on binary trees.
15
Recursive Algorithm for Binary Tree Traversal
If the binary tree is empty Do nothing
Else N: Visit the Node, process data L: Traverse the left subtree R: Traverse the right subtree
The "anchor"The "anchor"
The inductive stepThe inductive step
16
Binary Tree Traversal Order
Three possibilities for inductive step …
Left subtree, Node, Right subtreeInorder traversal
Node, Left subtree, Right subtreethe preorder traversal
Left subtree, Right subtree, Nodethe postorder traversal
17
Binary Search Tree
A Collection of Nodes Data
Must have <= and == operations Left Child Right Child
For each node x value in left child ≤ value in x ≤ value in right child
Binary Search Tree ADT
18
Construct an empty BST Determine if BST is empty Search BST for given item 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 will visit the values in the
nodes in ascending order
BST Basic Operations
19
Example
Create new empty C++ console application project.
Add to project: genBST1.h main.cpp
20
main.cpp
#include <iostream>
#include "genBST1.h"
using namespace std;
int main(void)
{
cout << "This is BST_Demo\n";
cin.get();
return 0;
}
Build and test.
21
genBST1.h
Copy from Downloads area: http://www.cse.usf.edu/~turnerr/Data_Structures/Down
loads/2011_03_02_Binary_Search_Tree/genBST1.h.txt
This is a subset of Drozdek’s genBST.h template. Figure 6.8, page 221 ff.
All textbook examples are available on the author's web site:
http://www.mathcs.duq.edu/drozdek/DSinCpp/
22
BSTNode
//************************ genBST1.h **************************
// generic binary search tree
#pragma once;
template<class T>
class BSTNode
{
public:
BSTNode()
{
left = right = 0;
}
BSTNode(const T& el, BSTNode *l = 0, BSTNode *r = 0)
{
key = el; left = l; right = r;
}
T key;
BSTNode *left, *right;
};
23
Class BST
template<class T>
class BST
{
public:
BST() {root = 0;}
~BST() {clear();}
void clear() // Overloaded
{
clear(root);
root = 0;
}
bool isEmpty() const {return root == 0;}
void insert(const T&);
T* search(const T& el) const // Overloaded
{
return search(root, el);
}
24
Class BST
protected:
BSTNode<T>* root;
void clear(BSTNode<T>*);
T* search(BSTNode<T>*, const T&) const;
//void preorder(BSTNode<T>*);
//void inorder(BSTNode<T>*);
//void postorder(BSTNode<T>*);
//virtual void visit(BSTNode<T>* p) {
// cout << p->key << ' ';
//}
};
25
BST<T>::clear()
template<class T>
void BST<T>::clear(BSTNode<T> *p)
{
if (p != 0)
{
clear(p->left);
clear(p->right);
delete p;
}
}
26
BST<T>::insert()
template<class T>
void BST<T>::insert(const T& el)
{
BSTNode<T> *p = root, *prev = 0;
// find a place for inserting new node;
while (p != 0)
{
prev = p;
if (p->key < el)
{
p = p->right;
}
else
{
p = p->left;
}
}
27
BST<T>::insert()
if (root == 0) // tree is empty;
{
root = new BSTNode<T>(el);
}
else if (prev->key < el)
{
prev->right = new BSTNode<T>(el);
}
else
{
prev->left = new BSTNode<T>(el);
}
}
28
BST<T>::search()
template<class T>
T* BST<T>::search(BSTNode<T>* p, const T& el) const
{
while (p != 0)
{
if (el == p->key)
{
return &p->key;
}
if (el < p->key)
{
p = p->left;
}
else
{
p = p->right;
}
}
return 0; // el was not found
}
29
Test BST Template
#include <iostream>
#include "genBST1.h"
using namespace std;
int main(void)
{
cout << "This is BST_Demo\n";
BST<int> my_BST;
my_BST.insert(13);
my_BST.insert(10);
my_BST.insert(25);
my_BST.insert(2);
my_BST.insert(12);
my_BST.insert(20);
my_BST.insert(31);
my_BST.insert(29);
30
Test BST Template
cout << "Items in the tree: ";
for (int i = 0; i < 100; ++i)
{
int* result = my_BST.search(i);
if (result != 0)
{
cout << i << " ";
}
}
cout << endl;
cin.get();
return 0;
}
31
Test Running
End of presentation
