**Binary Search Trees**CS 308 – Data Structures**What is a binary tree?**• Property1: each node can have up to two successor nodes (children) • The predecessor node of a node is called its parent • The "beginning" node is called the root (no parent) • A node without children is called a leaf**A Tree Has a Root Node**ROOT NODE Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len**Leaf nodes have no children**LEAF NODES Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len**What is a binary tree? (cont.)**• Property2: a unique path exists from the root to every other node**Some terminology**• Ancestor of a node: any node on the path from the root to that node • Descendant of a node: any node on a path from the node to the last node in the path • Level (depth) of a node: number of edges in the path from the root to that node • Height of a tree: number of levels (warning: some books define it as #levels - 1)**A Tree Has Levels**Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 0**Level One**LEVEL 1 Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len**Level Two**Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEVEL 2**A Subtree**Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len LEFT SUBTREE OF ROOT NODE**Another Subtree**Owner Jake Manager Chef Brad Carol Waitress Waiter Cook Helper Joyce Chris Max Len RIGHT SUBTREE OF ROOT NODE**What is the # of nodes N of a full tree withheight h?**The max #nodes at level is l=0 l=1 l=h-1 using the geometric series:**What is the height h of a full tree with N nodes?**• The max height of a tree with N nodes is N (same as a linked list) • The min height of a tree with N nodes is log(N+1)**Searching a binary tree**• (1) Start at the root • (2) Search the tree level by level, until you find the element you are searching for (O(N) time in worst case) • Is this better than searching a linked list? No ---> O(N)**Binary Search Trees**• Binary Search Tree Property:The value stored at a node is greater than the value stored at its left child and less than the value stored at its right child • Thus, the value stored at the root of a subtree is greater than any value in its left subtree and less than any value in its right subtree!!**Searching a binary search tree**• (1) Start at the root • (2) Compare the value of the item you are searching for with the value stored at the root • (3) If the values are equal, then item found; otherwise, if it is a leaf node, then not found**Searching a binary search tree(cont.)**• (4) If it is less than the value stored at the root, then search the left subtree • (5) If it is greater than the value stored at the root, then search the right subtree • (6) Repeat steps 2-6 for the root of the subtree chosen in the previous step 4 or 5 • Is this better than searching a linked list? Yes !! ---> O(logN)**Tree node structure**template<class ItemType> struct TreeNode { ItemType info; TreeNode* left; TreeNode* right; };**Binary Search Tree Specification**#include <fstream.h> template<class ItemType> struct TreeNode; enum OrderType {PRE_ORDER, IN_ORDER, POST_ORDER}; template<class ItemType> class TreeType { public: TreeType(); ~TreeType(); TreeType(const TreeType<ItemType>&); void operator=(const TreeType<ItemType>&); void MakeEmpty(); bool IsEmpty() const; bool IsFull() const; int NumberOfNodes() const; (continues)**Binary Search Tree Specification**(cont.) void RetrieveItem(ItemType&, bool& found); void InsertItem(ItemType); void DeleteItem(ItemType); void ResetTree(OrderType); void GetNextItem(ItemType&, OrderType, bool&); void PrintTree(ofstream&) const; private: TreeNode<ItemType>* root; }; };**Function NumberOfNodes**• Recursive implementation #nodes in a tree = #nodes in left subtree + #nodes in right subtree + 1 • What is the size factor? Number of nodes in the tree we are examining • What is the base case? The tree is empty • What is the general case? CountNodes(Left(tree)) + CountNodes(Right(tree)) + 1**Function NumberOfNodes (cont.)**template<class ItemType> int TreeType<ItemType>::NumberOfNodes() const { return CountNodes(root); } template<class ItemType> int CountNodes(TreeNode<ItemType>* tree) { if (tree == NULL) return 0; else return CountNodes(tree->left) + CountNodes(tree->right) + 1; }**Function RetrieveItem**• What is the size of the problem? Number of nodes in the tree we are examining • What is the base case(s)? • When the key is found • The tree is empty (key was not found) • What is the general case? Search in the left or right subtrees**Function RetrieveItem (cont.)**template <class ItemType> void TreeType<ItemType>:: RetrieveItem(ItemType& item,bool& found) { Retrieve(root, item, found); } template<class ItemType> void Retrieve(TreeNode<ItemType>* tree,ItemType& item,bool& found) { if (tree == NULL) // base case 2 found = false; else if(item < tree->info) Retrieve(tree->left, item, found); else if(item > tree->info) Retrieve(tree->right, item, found); else { // base case 1 item = tree->info; found = true; } }**Function InsertItem**• Use the binary search tree property to insert the new item at the correct place**Function InsertItem**(cont.) • Implementing insertion using recursion Insert 11**Function InsertItem (cont.)**• What is the size of the problem? Number of nodes in the tree we are examining • What is the base case(s)? The tree is empty • What is the general case? Choose the left or right subtree**Function InsertItem (cont.)**template<class ItemType> void TreeType<ItemType>::InsertItem(ItemType item) { Insert(root, item); } template<class ItemType> void Insert(TreeNode<ItemType>*& tree, ItemType item) { if(tree == NULL) { // base case tree = new TreeNode<ItemType>; tree->right = NULL; tree->left = NULL; tree->info = item; } else if(item < tree->info) Insert(tree->left, item); else Insert(tree->right, item); }**Function InsertItem (cont.)**Insert 11**Does the order of inserting elements into a tree matter?**• Yes, certain orders produce very unbalanced trees!! • Unbalanced trees are not desirable because search time increases!! • There are advanced tree structures (e.g.,"red-black trees") which guarantee balanced trees**Does the order of inserting elements into a tree matter?**(cont.)**Function DeleteItem**• First, find the item; then, delete it • Important: binary search tree property must be preserved!! • We need to consider three different cases: (1) Deleting a leaf (2) Deleting a node with only one child (3) Deleting a node with two children**(3) Deleting a node with two children (cont.)**• Find predecessor (it is the rightmost node in the left subtree) • Replace the data of the node to be deleted with predecessor's data • Delete predecessor node**Function DeleteItem (cont.)**• What is the size of the problem? Number of nodes in the tree we are examining • What is the base case(s)? Key to be deleted was found • What is the general case? Choose the left or right subtree**Function DeleteItem (cont.)**template<class ItemType> void TreeType<ItmeType>::DeleteItem(ItemType item) { Delete(root, item); } template<class ItemType> void Delete(TreeNode<ItemType>*& tree, ItemType item) { if(item < tree->info) Delete(tree->left, item); else if(item > tree->info) Delete(tree->right, item); else DeleteNode(tree); }**Function DeleteItem (cont.)**template <class ItemType> void DeleteNode(TreeNode<ItemType>*& tree) { ItemType data; TreeNode<ItemType>* tempPtr; tempPtr = tree; if(tree->left == NULL) { //right child tree = tree->right; delete tempPtr; } else if(tree->right == NULL) { // left child tree = tree->left; delete tempPtr; } else { GetPredecessor(tree->left, data); tree->info = data; Delete(tree->left, data); } } 0 or 1 child 0 or 1 child 2 children**Function DeleteItem (cont.)**template<class ItemType> void GetPredecessor(TreeNode<ItemType>* tree, ItemType& data) { while(tree->right != NULL) tree = tree->right; data = tree->info; }**Tree Traversals**There are mainly three ways to traverse a tree: • Inorder Traversal • Postorder Traversal • Preorder Traversal**‘J’**Inorder Traversal: A E H J M T Y Visit second tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘Y’ Visit left subtree first Visit right subtree last**Inorder Traversal**• Visit the nodes in the left subtree, then visit the root of the tree, then visit the nodes in the right subtree Inorder(tree) If tree is not NULL Inorder(Left(tree)) Visit Info(tree) Inorder(Right(tree)) (Warning: "visit" means that the algorithm does something with the values in the node, e.g., print the value)**‘J’**PostorderTraversal: A H E M Y T J Visit last tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘Y’ Visit left subtree first Visit right subtree second**Postorder Traversal**• Visit the nodes in the left subtree first, then visit the nodes in the right subtree, then visit the root of the tree Postorder(tree) If tree is not NULL Postorder(Left(tree)) Postorder(Right(tree)) Visit Info(tree)**‘J’**Preorder Traversal: J E A H T M Y Visit first tree ‘T’ ‘E’ ‘A’ ‘H’ ‘M’ ‘Y’ Visit left subtree second Visit right subtree last