Binary Search Trees 1

Transcription

1 Binary Search Tree A binary search tree is a binary tree that Stores data in an ordered fashion Provides fast access operations to Insert data in new nodes Remove old data and delete their nodes Search for data in existing nodes Left Subtree Root data Right Subtree < data t data The nodes in a binary search tree are ordered Nodes in a left subtree have data values less than root data Nodes in a right subtree have data greater than or equal to root data Ordering of nodes is done recursively in every subtree Binary Search Trees 1

2 Inserting into a Binary Search Tree To insert data into a binary search tree 1. If tree is empty then insert data as root node 2. If inserted data < root data then insert new node in left subtree Left Subtree. If inserted data t root data then insert new node in right subtree 4. To insert in a subtree, apply steps 1 through recursively Final binary search tree depends on the order of inserted data Inserted data may not be unique in every node To ensure the uniqueness of data then Inserted data > root data in right subtree (cannot be t) Root data Right Subtree < data t data Binary Search Trees 2

3 Insertion into a Binary Search Tree Consider the insertion of the following data sequences: 1,,,,,,, (tree1) 1,,,,,,, (tree2),,,, 1,,, (tree) Same data appear in all sequences, but in a different order Different insertion order Ÿ Different binary search trees Worst case when data is inserted in ascending or descending order tree1 1 tree2 1 tree 1 Binary Search Trees

4 Searching in a Binary Search Tree To search for data in a binary search tree Compare data with stored root data If equal, then found If less than, then recursively search left subtree If greater than, then recursively search right subtree If subtree is empty then data is not found For example, search for 1 Compare with 1 (>) search right subtree Compare with (>) then search right subtree Compare with (<) search left subtree Compare with (=) return pointer to node Maximum comparisons is tree height Binary Search Trees 4

5 Inorder Traversal of a Binary Search Tree Inorder traversal of a binary tree Traverses left subtree, then visits root node, then traverses right subtree When inorder traversal is applied to a binary search tree Nodes are visited in sorted order With inorder traversal, we define Inorder predecessor of a node is node visited inorder before current one Inorder successor of a node is node visited inorder after current one 1 Inorder traversal of both trees:,,,, 1,,, 1 Inorder predecessor of node 1 (root) is node Inorder successor of node 1 (root) is node Binary Search Trees 5

6 Deleting a Node from a Binary Search Tree Deleting a node from a binary search tree Is more involved than insertion or searching of nodes Is more complex than deleting a node in a linked list Can destroy the ordering of nodes We consider three cases Deleting a leaf node Deleting a node with one child Deleting a node with two children Deleting a leaf node is the simplest case 1 Example: deleting node Clear pointer to deleted node in parent node Rest of the tree is NOT affected Binary Search Trees 6

7 Deleting a Node with One Child Is just as easy as deleting a leaf node Example: deleting node Set right pointer in node 1 to point to node (left child of node ) The following code deletes a node with zero or one child TreeNode* subtree = curr->detachleft(); if (subtree == 0) subtree = curr->detachright(); if (root == curr) // Root node being deleted root = subtree; else if (parent->left() == curr) parent->attachleft(subtree); else parent->attachright(subtree); delete curr; 1 parent curr Binary Search Trees

8 Deleting a Node with Two Children Consider the deletion of root node 1 Breaks down the tree into a left and right subtrees Try to move a child node to replace the deleted parent node WRONG solution - resulting tree is not necessarily a binary search tree! What happens when each child node points to 2 nonempty subtrees??? 1 WRONG! WRONG! Binary Search Trees 8

9 Locating & Deleting the Inorder Predecessor To delete a node with 2 children and maintain correct ordering Locate the inorder predecessor of node to be deleted Go to left child and then move down to the right as far as possible Copy data of inorder predecessor node into current node Delete the inorder predecessor node and re-link its parent node Parent of inorder predecessor node now points to its left subtree Binary Search Trees 9

10 Alternative Solution Inorder Successor An alternative solution to deleting a node with 2 children Locate inorder successor of node to be deleted Go to right child and then move down to the left as far as possible Copy data of inorder successor node into current node Delete the inorder successor node and re-link its parent node Parent of inorder successor node now points to its right subtree Binary Search Trees 10

11 ADT Binary Search Tree Structure: Has a binary tree structure, where nodes have special ordering Operations: Constructor ( ) Purpose: Post: Constructor (tree) Purpose: Input: Post: Destructor () Purpose: Post: Empty ( ) o bool Purpose: Result: Construct an empty binary search tree Binary search tree is constructed and is empty Construct a binary search tree to be a duplicate of tree tree is a binary search tree to be duplicated Binary search tree is constructed as a copy of tree Delete entire tree pointed by root Binary search tree nodes are deleted and tree becomes empty Check emptiness of binary search tree True if binary search tree is empty and false otherwise Binary Search Trees 11

12 ADT BST: Search and Insert Operations: Search (data) o TreeNodePointer Purpose: Input: Result: Search for node that has data data value to be searched Pointer to node carrying data, or NULL if data is not found Insert (data) o TreeNodePointer Purpose: Input: Result: Post: Insert data at appropriate location in tree to maintain a BST data value to be inserted Pointer to newly inserted node A new node is inserted at appropriate location to hold data SearchInsert (data) o TreeNodePointer Purpose: Input: Result: Search and then Insert data to ensure uniqueness of data If node carrying data is found then return a pointer to it Otherwise, allocate a new node to carry data and return a pointer to it data value to be searched and inserted Pointer to node carrying data or to newly inserted node Binary Search Trees

13 ADT BST: Remove, Operator=, and Inorder Operations: Remove (data) o bool Purpose: Delete node that has data Pre: A node that holds data should exist in binary search tree Input: data value to be removed Result: True if data is found and false otherwise Post: Node that has data is deleted from binary search tree Operator= (tree) o BinarySearchTree Purpose: Assign a copy of tree to a binary search tree Input: tree is a binary search tree to be duplicated Result: A reference to assigned binary search tree Post: Binary search tree is assigned a copy of tree InOrder () Purpose: Inorder traversal of a binary search tree Inorder traversal visits nodes according to ascending order of data Post: Data in each node is processed according to a visit function Binary Search Trees 1

14 Binary Search Tree Class Specification class BST { // Binary Search Tree Class private: TreeNode* root; // Pointer to root node public: BST(); // Default constructor BST(const BST& t); // Copy constructor ~BST(); // Destructor BST& operator=(const BST& t); // Assignment operator bool empty() const; TreeNode* search(const DataType& data) const; TreeNode* insert(const DataType& data); TreeNode* searchinsert(const DataType& data); bool remove(const DataType& data); void inorder(); }; Binary Search Trees 14

15 Searching a Binary Search Tree TreeNode* BST::search(const DataType& data) { TreeNode* curr = root; // current node pointer } while (curr) { if (data == curr->data) // If found break; // Exit while loop else if (data < curr->data) // If smaller curr = curr->left(); // Go to left subtree else // If larger curr = curr->right(); // Go to right subtree } return curr; Binary Search Trees 15

16 Inserting a node into a Binary Search Tree TreeNode* BST::insert(const DataType& data) { } TreeNode* curr = root; TreeNode* parent = 0; while(curr) { // Locate insertion point parent = curr; if (data < curr->data) curr = curr->left(); else curr = curr->right(); } curr = new TreeNode(data); if (root == 0) root = curr; else if (data < parent->data) parent->attachleft(curr); else parent->attachright(curr); return curr; // Insert as root node // Insert as left child // Insert as right child Binary Search Trees

17 Searching and then Inserting into a BST TreeNode* BST::searchInsert(const DataType& data) { TreeNode* curr = root; TreeNode* parent = 0; while(curr) { if (data == curr->data) return curr; // Found parent = curr; if (data < curr->data) curr = curr->left(); else curr = curr->right(); } } curr = new TreeNode(data); if (root == 0) root = curr; else if (data < parent->data) parent->attachleft(curr); else parent->attachright(curr); return curr; // Not Found // Insert as root // As left child // As right child Binary Search Trees 1

18 Deleting a node from a Binary Search Tree bool BST::remove(const DataType& data) { TreeNode* curr = root; TreeNode* parent = 0; // Pointer to node with data // Pointer to parent node // Locate node to be deleted and its parent node while (curr) { if (curr->data == data) break; parent = curr; if (data < curr->data) curr = curr->left(); else curr = curr->right(); } // If NOT found then return false if (curr == 0) return false; // Continued on next slide... Binary Search Trees 18

19 Deleting a node with Zero or One Child if (curr->left() == 0 curr->right() == 0) { TreeNode* subtree = curr->detachleft(); if (subtree == 0) subtree = curr->detachright(); // If root node is being deleted if (curr == root) root = subtree; // If a left child is being deleted else if (parent->left() == curr) parent->attachleft(subtree); // If a right child is being deleted else parent->attachright(subtree); delete curr; return true; } // Continued on next slide... Binary Search Trees 19

20 Deleting a Node with Two Children // Locate the in-order predecessor and its parent TreeNode* pred = curr->left(); parent = curr; while (pred->right()) { parent = pred; pred = pred->right(); } // Go left first // Copy data of predecessor to current node curr->data = pred->data; // Move down to the right // as far as possible } // Delete in-order predecessor node and re-link its parent TreeNode* subtree = pred->detachleft(); parent->attachright(subtree); delete pred; return true; Binary Search Trees 20

21 Complexity of Binary Search Tree Operations Best Case is when binary search tree is full or near full Tree Height = O(log 2 n), where n is the number of nodes Worst case is when binary search tree is linear or almost linear Tree Height = n,or almost n Locating a node is O(Height) on average Nodes along path from root are visited only If tree is bushy (full or near full) then Locating a node is O(log 2 n) If tree is linear or near linear then Locating a node is O(n) Insertion and Deletion Are based on locating a node O(log 2 n) Best and average cases O(n) Worst case 1 Best Case 102 Worst Case Binary Search Trees 21