This preview shows page 1. Sign up to view the full content.
Unformatted text preview: What is a (General) Tree?
• A (general) tree is a set of nodes with the following proper4es: – The set can be empty. – Otherwise, the set is par44oned into k+1 disjoint subsets: • a tree consists of a dis4nguished node r, called root, and zero or more nonempty sub
trees T1, T2, … , Tk, each of whose roots are connected by an edge from r. • T is a tree if either – T has no nodes, or – T is of the form: r T1 T2 Tk where r is a node and T1, T2, ..., Tk are trees. 3/7/11 CS202
Fundamentals of Computer Science II
1
What is a (General) Tree? (cont.)
• The root of each sub
tree is said to be child of r, and r is the parent of each sub
tree root. • If a tree is a collecFon of N nodes, then it has N
1 edges. • A path from node n1 to nk is deﬁned as a sequence of nodes n1,n2, …,nk such that ni is parent of ni+1 (1 ≤ i < k) – There is a path from every node to itself. – There is exactly one path from the root to each node. 3/7/11 CS202
Fundamentals of Computer Science II
2
Tree Terminology
Parent – The parent of node n is the node directly above in the tree. Child – The child of node n is the node directly below in the tree. • If node m is the parent of node n, node n is the child of node m. Root – The only node in the tree with no parent. Leaf – A node with no children. Siblings – Nodes with a common parent. Ancestor – An ancestor of node n is a node on the path from the root to n. Descendant – A descendant of node n is a node on the path from n to a leaf. Subtree – A subtree of node n is a tree that consists of a child (if any) of n and the child’s descendants (a tree which is rooted by a child of node n) 3/7/11 CS202
Fundamentals of Computer Science II
3
A Tree – Example A B C D H E I F J P K L G M N Q – Node A has 6 children: B, C, D, E, F, G. – B, C, H, I, P, Q , K, L, M, N are leaves in the tree above. – K, L, M are siblings since F is parent of all of them. 3/7/11 CS202
Fundamentals of Computer Science II
4
Level of a node
Level – The level of node n is the number of nodes on the path from root to node n. DeﬁniFon: The level of node n in a tree T – If n is the root of T, the level of n is 1. – If n is not the root of T, its level is 1 greater than the level of its parent. 3/7/11 CS202
Fundamentals of Computer Science II
5
Height of A Tree
Height – The number of nodes on the longest path from the root to a leaf. • The height of a tree T in terms of the levels of its nodes is deﬁned as: – If T is empty, its height is 0 – If T is not empty, its height is equal to the maximum level of its nodes. • Or, the height of a tree T can be deﬁned as recursively as: – If T is empty, its height is 0. – If T is non
empty tree, then since T is of the form: r T1 T2 Tk height(T) = 1 + max{height(T1),height(T2),...,height(Tk)}
3/7/11 CS202
Fundamentals of Computer Science II
6
Binary Tree
• A binary tree T is a set of nodes with the following proper4es: – The set can be empty. – Otherwise, the set is par44oned into three disjoint subsets: • a tree consists of a dis4nguished node r, called root, and • two possibly empty sets are binary tree, called le< and right subtrees of r. • T is a binary tree if either – T has no nodes, or – T is of the form: r
TL TR where r is a node and TL and TR are binary trees. 3/7/11 CS202
Fundamentals of Computer Science II
7
Binary Tree Terminology
Le< Child – The lee child of node n is a node directly below and to the lee of node n in a binary tree. Right Child – The right child of node n is a node directly below and to the right of node n in a binary tree. Le< Subtree – In a binary tree, the lee subtree of node n is the lee child (if any) of node n plus its descendants. Right Subtree – In a binary tree, the right subtree of node n is the right child (if any) of node n plus its descendants. 3/7/11 CS202
Fundamentals of Computer Science II
8
Binary Tree
Example
• A is the root.
• B is the left child of A, and
C is the right child of A.
• D doesn t have a right child.
• H doesn t have a left child.
• B, F, G and I are leaves. •A
•C •B •D
•F •E
•G •H
•I 3/7/11 CS202
Fundamentals of Computer Science II
9
Binary Tree – RepresenEng Algebraic Expressions
3/7/11 CS202
Fundamentals of Computer Science II
10
Height of Binary Tree
• The height of a binary tree T can be deﬁned as recursively as: – If T is empty, its height is 0. – If T is non
empty tree, then since T is of the form r TL TR the height of T is 1 greater than the height of its root s taller subtree; ie. height(T) = 1 + max{height(TL),height(TR)} 3/7/11 CS202
Fundamentals of Computer Science II
11
Height of Binary Tree (cont.)
Binary trees with the same nodes but different heights
3/7/11 CS202
Fundamentals of Computer Science II
12
Number of Binary trees with Same # of Nodes
empty tree
(1 tree) • n=0 n=1 • n=2 • • •
• n=3 •
• (2 trees) •
• •
• • •
• • • (5 trees) • • • ( n!1)/ 2 n is even NumBT ( N ) = 2 " ( NumBT (i ) NumBT (n ! i ! 1)) i=0
(( n!1)/ 2 )!1 NumBT ( N ) = 2 n is odd " ( NumBT (i ) NumBT (n ! i ! 1)) i=0 + NumBT ((n ! 1) / 2 ) NumBT ((n ! 1) / 2 )
3/7/11 CS202
Fundamentals of Computer Science II
13
Full Binary Tree
• In a full binary tree of height h, all nodes that are at a level less than h have two children each. • Each node in a full binary tree has lee and right subtrees of the same height. • Among binary trees of height h, a full binary tree has as many leaves as possible, and they all are at level h. • A full binary has no missing nodes. • Recursive deﬁniFon of full binary tree: – If T is empty, T is a full binary tree of height 0. – If T is not empty and has height h>0, T is a full binary tree if its root s subtrees are both full binary trees of height h
1. 3/7/11 CS202
Fundamentals of Computer Science II
14
Full Binary Tree – Example A full binary tree of height 3 3/7/11 CS202
Fundamentals of Computer Science II
15
Complete Binary Tree
• A complete binary tree of height h is a binary tree that is full down to level h
1, with level h ﬁlled in from lee to right. • A binary tree T of height h is complete if 1. All nodes at level h
2 and above have two children each, and 2. When a node at level h
1 has children, all nodes to its lee at the same level have two children each, and 3. When a node at level h
1 has one child, it is a lee child. – A full binary tree is a complete binary tree. 3/7/11 CS202
Fundamentals of Computer Science II
16
Complete Binary Tree – Example 3/7/11 CS202
Fundamentals of Computer Science II
17
Balanced Binary Tree
• A binary tree is height balanced (or balanced), if the height of any node s right subtree diﬀers from the height of the node s lee subtree by no more than 1. • A complete binary tree is a balanced tree. • Later, we look at other height balanced trees. – AVL trees – Red
Black trees, .... 3/7/11 CS202
Fundamentals of Computer Science II
18
Maximum and Minimum Heights of a Binary Tree
• The eﬃciency of most of the binary tree operaFons depends on the height of the tree. • The maximum number of key comparisons for retrieval, deleFon, and inserFon operaFons for BSTs is the height of the tree. • The maximum of height of a binary tree with n nodes is n. • Each level of a minimum height tree, except the last level, must contain as many nodes as possible. 3/7/11 CS202
Fundamentals of Computer Science II
19
Maximum and Minimum Heights of a Binary Tree
A maximumheight binary tree
with seven nodes 3/7/11 Some binary trees of height 3 CS202
Fundamentals of Computer Science II
20
CounEng the nodes in a full binary tree of height h
3/7/11 CS202
Fundamentals of Computer Science II
21
Some Height Theorems
Theorem: A full binary of height h≥0 has 2h
1 nodes. – The maximum number of nodes that a binary tree of height h can have is 2h
1. We cannot insert a new node into a full binary tree without increasing its height. 3/7/11 CS202
Fundamentals of Computer Science II
22
Some Height Theorems
Theorem 10
4: The minimum height of a binary tree with n nodes is Ⱥlog2(n+1)Ⱥ . Proof: Let h be the smallest integer such that n≤2h
1. We can establish following facts: Fact 1 – A binary tree whose height is ≤ h
1 has < n nodes. – Otherwise h cannot be smallest integer in our assumpFon. Fact 2 – There exists a complete binary tree of height h that has exactly n nodes. – A full binary tree of height h
1 has 2h
1
1 nodes. – Since a binary tree of height h cannot have more than 2h
1 nodes. – At level h, we will reach n nodes. Fact 3 – The minimum height of a binary tree with n nodes is the smallest integer h such that n ≤2h
1. So, 2h
1
1 < n ≤ 2h
1 2h
1 < n+1 ≤ 2h h
1 < log2(n+1) ≤ h Thus, h = Ⱥlog2(n+1)Ⱥ is the minimum height of a binary tree with n nodes. 3/7/11 CS202
Fundamentals of Computer Science II
23
An Array
Based ImplementaEon of Binary Trees
const int MAX_NODES = 100;
!// maximum number of nodes typedef string TreeItemType;!
class TreeNode { !
!
!// node in the tree private: !TreeNode(); !TreeNode(const TreeItemType& nodeItem, int left, int right);
!
!TreeItemType item;
!int leftChild; !
!int rightChild; !
!
! !// data portion !// index to left child !// index to right child !// friend class  can access private parts !friend class BinaryTree; }; // An array of tree nodes TreeNode[MAX_NODES] tree; int root; int free; 3/7/11 CS202
Fundamentals of Computer Science II
24
An Array
Based ImplementaEon (cont.)
• A free list keeps track of available nodes. • To insert a new node into the tree, we ﬁrst obtain an available node from the free list. • When we delete a node from the tree, we have to place into the free list so that we can use it later. 3/7/11 CS202
Fundamentals of Computer Science II
25
An Array
Based RepresentaEon of a Complete Binary Tree
• If we know that our binary tree is a complete binary tree, we can use a simpler array
based representaFon for complete binary trees • without using leeChild and rightChild links • We can number the nodes level by level, and lee to right (starFng from 0, the root will be 0). If a node is numbered as i, in the ith locaFon of the array, tree[i], contains this node without links. • Using these numbers we can ﬁnd leeChild, rightChild, and parent of a node i. The lee child (if it exists) of node i is tree[2*i+1]! The right child (if it exists) of node i is tree[2*i+2]! The parent (if it exists) of node i is 3/7/11 CS202
Fundamentals of Computer Science II
tree[(i1)/2]! 26
An Array
Based RepresentaEon of a Complete Binary Tree (cont.)
0 1 3 3/7/11 2 4 5 CS202
Fundamentals of Computer Science II
27
Pointer
Based ImplementaEon of Binary Trees 3/7/11 CS202
Fundamentals of Computer Science II
28
A Pointer
Based ImplementaEon of
a Binary Tree Node
typedef string TreeItemType;!
class TreeNode {
// node in the tree!
private:!
TreeNode() {}!
TreeNode(const TreeItemType& nodeItem,!
TreeNode *left = NULL,!
TreeNode *right = NULL)!
:item(nodeItem),leftChildPtr(left),rightChildPtr(right) {}!
TreeItemType item;
// data portion!
TreeNode *leftChildPtr; // pointer to left child!
TreeNode *rightChildPtr; // pointer to right child!
friend class BinaryTree;!
}; ! 3/7/11 CS202
Fundamentals of Computer Science II
29
Binary Tree – TreeExcepEon.h
class TreeException : public exception{ private: string msg; public: !virtual const char* what() const throw() !{ ! !return msg.c_str(); !}!
TreeException(const string & message =""): !exception(), msg(message) {};!
!~TreeException() throw() {}; }; // end TreeException 3/7/11 CS202
Fundamentals of Computer Science II
30
The BinaryTree Class
• ProperFes – TreeNode * root! • Constructors – BinaryTree();!
– BinaryTree(const TreeItemType& rootItem);!
– BinaryTree(const TreeItemType& rootItem, !
!!
!
BinaryTree& leftTree, BinaryTree& rightTree);!
– BinaryTree(const BinaryTree& tree);!
• void copyTree(TreeNode *treePtr, TreeNode* & newTreePtr) const;! • Destructor – ~BinaryTree();!
• void destroyTree(TreeNode * &treePtr);! 3/7/11 CS202
Fundamentals of Computer Science II
31
BinaryTree: Public Methods
•
•
•
•
•
•
•
•
•
•
•
•
•
• bool isEmpty()!
TreeItemType rootData() const throw(TreeException)!
void setRootData(const TreeItemType& newItem)!
void attachLeft(const TreeItemType& newItem)!
void attachRight(const TreeItemType& newItem)!
void attachLeftSubtree(BinaryTree& leftTree)!
void attachRightSubtree(BinaryTree& rightTree)!
void detachLeftSubtree(BinaryTree& leftTree)!
void detachRightSubtree(BinaryTree& rightTree)!
BinaryTree leftSubtree()!
BinaryTree rightSubtree()!
void preorderTraverse(FunctionType visit_fn)!
void inorderTraverse(FunctionType visit_fn)!
void postorderTraverse(FunctionType visit_fn)!
• FunctionType is a pointer to a funcFon:
• typedef void (*FunctionType)(TreeItemType& anItem);! 3/7/11 CS202
Fundamentals of Computer Science II
32
BinaryTree: ImplementaEon • The complete implementaFon is in your text book • In class, we will go through only some methods – Skipping straighoorward methods • Such as isEmpty, rootData, and setRootData funcFons – Skipping some details • Such as throwing excepFons 3/7/11 CS202
Fundamentals of Computer Science II
33
// Default constructor!
BinaryTree::BinaryTree() : root(NULL) {!
}! // Protected constructor!
BinaryTree::BinaryTree(TreeNode *nodePtr) : root(nodePtr) {!
}! // Constructor!
BinaryTree::BinaryTree(const TreeItemType& rootItem) {!
!
!root = new TreeNode(rootItem, NULL, NULL);!
}! 3/7/11 CS202
Fundamentals of Computer Science II
34
// Constructor!
BinaryTree::BinaryTree(const TreeItemType& rootItem, !
!
!
!
! BinaryTree& leftTree, BinaryTree& rightTree) {!
!
!root = new TreeNode(rootItem, NULL, NULL);!
!
!attachLeftSubtree(leftTree);!
!
!attachRightSubtree(rightTree);!
}!
void BinaryTree::attachLeftSubtree(BinaryTree& leftTree) {!
!
!// Assertion: nonempty tree; no left child!
!
!if (!isEmpty() && (root>leftChildPtr == NULL)) {!
!
!
!root>leftChildPtr = leftTree.root;!
!
!
!leftTree.root = NULL!
!
!}!
}!
void BinaryTree::attachRightSubtree(BinaryTree& rightTree) {!
!
!// Left as an exercise!
}! 3/7/11 CS202
Fundamentals of Computer Science II
35
// Copy constructor!
BinaryTree::BinaryTree(const BinaryTree& tree) {!
!
!copyTree(tree.root, root);!
}! // Uses preorder traversal for the copy operation!
// (Visits first the node and then the left and right children)!
void BinaryTree::copyTree(TreeNode *treePtr, TreeNode *& newTreePtr) const {
!
!
!
!
!
!
!
!
}! 3/7/11 !if (treePtr != NULL) {
!
!// copy node!
!
!newTreePtr = new TreeNode(treePtr>item, NULL, NULL);!
!
!copyTree(treePtr>leftChildPtr, newTreePtr>leftChildPtr);!
!
!copyTree(treePtr>rightChildPtr, newTreePtr>rightChildPtr);!
!}!
!else!
!
!newTreePtr = NULL;
!// copy empty tree! CS202
Fundamentals of Computer Science II
36
// Destructor!
BinaryTree::~BinaryTree() {!
!
!destroyTree(root);!
}! // Uses postorder traversal for the destroy operation!
// (Visits first the left and right children and then the node)!
void BinaryTree::destroyTree(TreeNode *& treePtr) {!
!
!
!
!
!
!
}! 3/7/11 !if (treePtr != NULL){!
!
!destroyTree(treePtr>leftChildPtr);!
!
!destroyTree(treePtr>rightChildPtr);!
!
!delete treePtr;!
!
!treePtr = NULL;!
!}! CS202
Fundamentals of Computer Science II
37
Binary Tree Traversals
• Preorder Traversal – The node is visited before its lee and right subtrees, • Postorder Traversal – The node is visited aeer both subtrees. • Inorder Traversal – The node is visited between the subtrees, – Visit lee subtree, visit the node, and visit the right subtree. 3/7/11 CS202
Fundamentals of Computer Science II
38
Binary Tree Traversals
3/7/11 CS202
Fundamentals of Computer Science II
39
void BinaryTree::preorderTraverse(FunctionType visit) {!
!
!preorder(root, visit);!
}!
void BinaryTree::inorderTraverse(FunctionType visit) {!
!
!inorder(root, visit);!
}!
void BinaryTree::postorderTraverse(FunctionType visit) {!
!
!postorder(root, visit);!
}!
Remember that FunctionType is a pointer to a funcFon • Variables that point to the address of a funcFon • typedef void (*FunctionType)(TreeItemType& anItem);!
Example of using inorderTraverse funcFon • void display(TreeItemType& anItem) { cout << anItem << endl; } • BinaryTree T1;!
!T1.inorderTraverse(display);!
3/7/11 CS202
Fundamentals of Computer Science II
40
void BinaryTree::preorder(TreeNode *treePtr, FunctionType visit) {!
!
!if (treePtr != NULL) {!
!
!
!visit(treePtr>item);!
!
!
!preorder(treePtr>leftChildPtr, visit);!
!
!
!preorder(treePtr>rightChildPtr, visit);!
!
!}!
}!
void BinaryTree::inorder(TreeNode *treePtr, FunctionType visit) {!
!
!if (treePtr != NULL) {!
!
!
!inorder(treePtr>leftChildPtr, visit);!
!
!
!visit(treePtr>item);!
!
!
!inorder(treePtr>rightChildPtr, visit);!
!
!}!
}!
void BinaryTree::postorder(TreeNode *treePtr, FunctionType visit) {!
!
!if (treePtr != NULL) {!
!
!
!postorder(treePtr>leftChildPtr, visit);!
!
!
!postorder(treePtr>rightChildPtr, visit);!
!
!
!visit(treePtr>item);!
!
!}!
3/7/11 CS202
Fundamentals of Computer Science II
}! 41
Binary Search Tree
• An important applicaFon of binary trees is their use in searching. • Binary search tree is a binary tree in which every node X contains a
data value that saFsﬁes the following: a) all data values in its lee subtree are smaller than the data value in X b) the data value in X is smaller than all the values in its right subtree c) the lee and right subtrees are also binary search trees 3/7/11 CS202
Fundamentals of Computer Science II
42
Binary Search Tree
6 2 1 6 8 4 2 1 3 A binary search tree 3/7/11 8 4 3 7 Not a binary search tree,
but a binary tree
CS202
Fundamentals of Computer Science II
43
Binary Search Trees – containing same data
3/7/11 CS202
Fundamentals of Computer Science II
44
BinarySearchTree Class – UML Diagram
3/7/11 CS202
Fundamentals of Computer Science II
45
The KeyedItem Class
typedef desiredtypeofsearchkey KeyType;!
class KeyedItem {!
public:!
!
!KeyedItem() { } !
!
!KeyedItem(const KeyType& keyValue) : searchKey(keyValue) { }!
!
!
! !KeyType getKey() const { !
!
!return searchKey;!
!}! private:!
!
!KeyType searchKey;!
!
!// ... and other data items!
};! 3/7/11 CS202
Fundamentals of Computer Science II
46
The TreeNode Class
typedef KeyedItem TreeItemType;!
class TreeNode {
!// a node in the tree!
private:!
!
!TreeNode() { }!
!
!TreeNode(const TreeItemType& nodeItem,TreeNode *left = NULL, !
!
!
!
!
!
!
!
TreeNode *right = NULL)
!
!
!: item(nodeItem), leftChildPtr(left), rightChildPtr(right){ }
! !
!
! !TreeItemType item; !
!// a data item in the tree!
!TreeNode *leftChildPtr;
!// pointers to children !
!TreeNode *rightChildPtr; ! !// friend class  can access private parts!
!friend class BinarySearchTree;!
};!
3/7/11 CS202
Fundamentals of Computer Science II
47
The BinarySearchTree Class
• ProperFes – TreeNode * root! • Constructors – BinarySearchTree();!
– BinarySearchTree(const BinarySearchTree& tree);! • Destructor – ~BinarySearchTree();! 3/7/11 CS202
Fundamentals of Computer Science II
48
The BinarySearchTree Class
• Public methods!
– bool isEmpty() const;!
– void searchTreeRetrieve(KeyType searchKey, TreeItemType& item);!
– void searchTreeInsert(const TreeItemType& newItem);!
– void searchTreeDelete(KeyType searchKey);!
– void preorderTraverse(FunctionType visit);!
– void inorderTraverse(FunctionType visit);!
– void postorderTraverse(FunctionType visit);!
– BinarySearchTree& operator=(const BinarySearchTree& rhs);! 3/7/11 CS202
Fundamentals of Computer Science II
49
The BinarySearchTree Class
• Protected methods!
– void retrieveItem(TreeNode *treePtr, KeyType searchKey, !
!!
!
!
!
!TreeItemType& item); ! – void insertItem(TreeNode * &treePtr,const TreeItemType& item);! – void deleteItem(TreeNode * &treePtr, KeyType searchKey);!
– void deleteNodeItem(TreeNode * &nodePtr);!
– void processLeftmost(TreeNode * &nodePtr, TreeItemType& item);! 3/7/11 CS202
Fundamentals of Computer Science II
50
Searching (Retrieving) an Item in a BST
void BinarySearchTree::searchTreeRetrieve(KeyType searchKey,!
!
!
!
!TreeItemType& treeItem) const throw(TreeException) {
!
!
!retrieveItem(root, searchKey, treeItem);!
}! void BinarySearchTree::retrieveItem(TreeNode *treePtr, KeyType searchKey,!
!
!
!
!TreeItemType& treeItem) const throw(TreeException) {
!
!
!
!
!
!
!
!
!
}!
3/7/11 !if (treePtr == NULL)!
!
!throw TreeException("TreeException: searchKey not found");!
!else if (searchKey == treePtr>item.getKey())!
!
!treeItem = treePtr>item;!
!else if (searchKey < treePtr>item.getKey())!
!
!retrieveItem(treePtr>leftChildPtr, searchKey, treeItem);!
!else!
!
!retrieveItem(treePtr>rightChildPtr, searchKey, treeItem);! CS202
Fundamentals of Computer Science II
51
InserEng an Item into a BST
Insert 5 Search determines the insertion point.
6
2
1 4
3 3/7/11 8 CS202
Fundamentals of Computer Science II
5 52
InserEng an Item into a BST
void BinarySearchTree::searchTreeInsert(const TreeItemType& newItem) {!
!
!insertItem(root, newItem);!
}! void BinarySearchTree::insertItem(TreeNode *& treePtr, !
!
!
!
!const TreeItemType& newItem) throw(TreeException) {!
!
!
!
!
!
!
!
!
!
!
!
}!
3/7/11 !// Position of insertion found; insert after leaf!
!if (treePtr == NULL) { !
!
!treePtr = new TreeNode(newItem, NULL, NULL);!
!
!if (treePtr == NULL)!
!
!
!throw TreeException("TreeException: insert failed");
!
!}!
!// Else search for the insertion position!
!else if (newItem.getKey() < treePtr>item.getKey()) !
!
!insertItem(treePtr>leftChildPtr, newItem);!
!else!
!
!insertItem(treePtr>rightChildPtr, newItem);!
CS202
Fundamentals of Computer Science II
53
InserEng an Item into a BST
3/7/11 CS202
Fundamentals of Computer Science II
54
DeleEng An Item from a BST
• To delete an item from a BST, we have to locate that item in that BST. • The deleted node can be: – Case 1 – A leaf node. – Case 2 – A node with only with child (with lee child or with right child). – Case 3 – A node with two children. 3/7/11 CS202
Fundamentals of Computer Science II
55
DeleEon – Case 1: A Leaf Node
To remove the leaf containing the item, we have to set the pointer in its parent to NULL. 50
40
30 50 60
45 70 40
30 42 60
45 42 Delete 70 (A leaf node) 3/7/11 CS202
Fundamentals of Computer Science II
56
DeleEon – Case 2: A Node with only a leV child
50 50
40
30 60
45 70 40
30 60
42 70 42 Delete 45 (A node with only a lee child) 3/7/11 CS202
Fundamentals of Computer Science II
57
DeleEon – Case 2: A Node with only a right child
50 50
40
30 60
45 40 30 70 70
45 42 42 Delete 60 (A node with only a right child) 3/7/11 CS202
Fundamentals of Computer Science II
58
DeleEon – Case 3: A Node with two children
• Locate the inorder successor of the node. • Copy the item in this node into the node which contains the item which will be deleted. • Delete the node of the inorder successor. 50 50
40
30 60
45 70 42
30 60
45 70 42
Delete 40 (A node with two children) 3/7/11 CS202
Fundamentals of Computer Science II
59
DeleEon – Case 3: A Node with two children
3/7/11 CS202
Fundamentals of Computer Science II
60
DeleEon – Case 3: A Node with two children
Delete 2 3/7/11 CS202
Fundamentals of Computer Science II
61
DeleEon from a BST
void BinarySearchTree::searchTreeDelete(KeyType searchKey) !
!
!
!
!
!
!
!
!throw(TreeException) {
!
!
!deleteItem(root, searchKey);!
}!
void BinarySearchTree::deleteItem(TreeNode * &treePtr, KeyType searchKey) !
!
!
!
!
!
!
!
!throw(TreeException) {
!
!
!if (treePtr == NULL) // Empty tree!
!
!
!throw TreeException("Delete failed"); !
!
!!
!
!// Position of deletion found!
!
!else if (searchKey == treePtr>item.getKey())!
!
!
!deleteNodeItem(treePtr);!
!
!
!
!
!
}!
3/7/11 !// Else search for the deletion position!
!else if (searchKey < treePtr>item.getKey())!
!
!deleteItem(treePtr>leftChildPtr, searchKey);!
!else!
!
!deleteItem(treePtr>rightChildPtr, searchKey);!
CS202
Fundamentals of Computer Science II
62
DeleEon from a BST
void BinarySearchTree::deleteNodeItem(TreeNode * &nodePtr) {!
!
!TreeNode *delPtr;!
!
!TreeItemType replacementItem;! !
!
!
!
!
! !
!
!
!
!
!
!
3/7/11 !// (1) Test for a leaf!
!if ( (nodePtr>leftChildPtr == NULL) && !
!
(nodePtr>rightChildPtr == NULL) ) {!
!
!delete nodePtr;!
!
!nodePtr = NULL;!
!}! !// (2) Test for no left child!
!else if (nodePtr>leftChildPtr == NULL){!
!
!delPtr = nodePtr;!
!
!nodePtr = nodePtr>rightChildPtr;!
!
!delPtr>rightChildPtr = NULL; !
!
!delete delPtr;!
!}!
CS202
Fundamentals of Computer Science II
63
DeleEon from a BST
!
!
!
!
! !// (3) Test for no right child!
!else if (nodePtr>rightChildPtr == NULL) {!
!
!// ...!
!
!// Left as an exercise !
!}! !
!
!
!
!
! !// (4) There are two children:!
!//
Retrieve and delete the inorder successor!
!else {!
!
!processLeftmost(nodePtr>rightChildPtr, replacementItem);!
!
!nodePtr>item = replacementItem;!
!}! }! 3/7/11 CS202
Fundamentals of Computer Science II
64
DeleEon from a BST
void BinarySearchTree::processLeftmost(TreeNode *&nodePtr, !
!
!
!
!
!
! TreeItemType& treeItem){!
!
!
!
!
!
!
!
!
!
}! 3/7/11 !if (nodePtr>leftChildPtr == NULL) {!
!
!treeItem = nodePtr>item;!
!
!TreeNode *delPtr = nodePtr;!
!
!nodePtr = nodePtr>rightChildPtr;!
!
!delPtr>rightChildPtr = NULL; // defense!
!
!delete delPtr;!
!}!
!else!
!
!processLeftmost(nodePtr>leftChildPtr, treeItem);! CS202
Fundamentals of Computer Science II
65
Traversals
• The traversals for binary search trees are same as the traversals for the binary trees. Theorem: Inorder traversal of a binary search tree will visit its nodes in sorted search
key order. Proof: Proof by inducFon on the height of the binary search tree T. Basis: h=0 no nodes are visited, empty list is in sorted order. Induc4ve Hypothesis: Assume that the theorem is true for all k, 0≤k<h Induc4ve Conclusion: We have to show that the theorem is true for k=h>0. T should be: Since the lengths of TL and TR are less than h, the theorem holds r
for them. All the keys in TL are less than r, and all the keys in TR are greater than r. In inorder traversal, we visit TL ﬁrst, then r, and then TR. T T Thus, the theorem holds for T with height k=h. L 3/7/11 R CS202
Fundamentals of Computer Science II
66
Minimum Height
• Complete trees and full trees have minimum height. • The height of an n
node binary search tree ranges from Ⱥlog2(n+1)Ⱥ to n. • InserFon in search
key order produces a maximum
height BST. • InserFon in random order produces a near
minimum
height BST. • That is, the height of an n
node binary search tree
– Best Case –
Ⱥlog2(n+1)Ⱥ O(log2n) – Worst Case – n O(n) – Average Case – close to Ⱥlog2(n+1)Ⱥ O(log2n) 3/7/11 CS202
Fundamentals of Computer Science II
67
Average Height
• If we insert n items into an empty BST to create a BST with n nodes, – How many diﬀerent binary search trees with n nodes? – What are their probabiliFes? • There are n! diﬀerent orderings of n keys. – But how many diﬀerent binary search trees with n nodes? n=0 1 BST (empty tree) n=1 1 BST (a binary tree with a single node) n=2 2 BSTs •
•
•
•
When n=3
n=3 5 BSTs • •
Probabilities:
1/6
Insertion Order: 3,2,1
3/7/11 CS202
Fundamentals of Computer Science II
• •• • 1/6
3,1,2 2/6
2,1,3
2,3,1 • •
• 1/6
1,3,2 •
•
1/6
1,2,3
68
Order of OperaEons on BSTs
3/7/11 CS202
Fundamentals of Computer Science II
69
Treesort
• We can use a binary search tree to sort an array. // Sorts n integers in an array anArray into !
// ascending order!
treesort(inout anArray:ArrayType, in n:integer) !
!
! !Insert anArray’s elements into a binary search !
!tree bTree! !
!
! !Traverse bTree in inorder. As you visit bTree’s!
!nodes, copy their data items into successive!
!locations of anArray! 3/7/11 CS202
Fundamentals of Computer Science II
70
Treesort Analysis
• InserFng an item into a binary search tree: – Worst Case: O(n) – Average Case: O(log2n) • InserFng n items into a binary search tree: – Worst Case: O(n2) – Average Case: O(n*log2n) (1+2+...+n) = O(n2) • Inorder traversal and copy items back into array O(n) • Thus, treesort is O(n2) in worst case, and O(n*log2n) in average case. • Treesort makes exactly same key comparisons of keys as does quicksort when the pivot for each sublist is chosen to be the ﬁrst key 3/7/11 CS202
Fundamentals of Computer Science II
71
Saving a BST into a ﬁle and restoring it to its original shape
• Save: – Use a preorder traversal to save the nodes of the BST into a ﬁle • Restore: – Start with an empty BST – Read the nodes from the ﬁle one by one and insert them into the BST 3/7/11 CS202
Fundamentals of Computer Science II
72
Saving a BST into a ﬁle and restoring it to its original shape
Preorder: 60 20 10 40 30 50 70 3/7/11 CS202
Fundamentals of Computer Science II
73
Saving a BST into a ﬁle and restoring it to a minimum
height BST
• Save: – Use an inorder traversal to save the nodes of the BST into a ﬁle. The saved nodes will be in ascending order – Save the number of nodes (n) in somewhere • Restore: – Read the number of nodes (n) – Start with an empty BST – Read the nodes from the ﬁle one by one to create a minimum
height binary search tree 3/7/11 CS202
Fundamentals of Computer Science II
74
Building a minimum
height BST
// Builds a minimumheight binary search tree from n sorted!
// values in a file. treePtr will point to the tree’s root.!
readTree(out treePtr:TreeNodePtr, in n:integer)!
!
! !if (n>0) {!
!
!treePtr = pointer to new node with NULL child pointers! !
! !
! !// construct the left subtree!
!readTree(treePtr>leftChildPtr, n/2)! !
! !
! !// get the root!
!Read item from file into treePtr>item! !
!
! !
!
!}! !// construct the right subtree!
!readTree(treePtr>rightChildPtr, (n1)/2)! 3/7/11 CS202
Fundamentals of Computer Science II
75
A full tree saved in a ﬁle by using inorder traversal
3/7/11 CS202
Fundamentals of Computer Science II
76
A General Tree
3/7/11 CS202
Fundamentals of Computer Science II
77
A Pointer
Based ImplementaEon of General Trees
3/7/11 CS202
Fundamentals of Computer Science II
78
A Pointer
Based ImplementaEon of General Trees
A pointerbased implementation of
a general tree can also represent
a binary tree. 3/7/11 CS202
Fundamentals of Computer Science II
79
N
ary Tree
An nary tree is a generalization of a binary whose
nodes each can have no more than n children. 3/7/11 CS202
Fundamentals of Computer Science II
80
...
View
Full
Document
This note was uploaded on 10/23/2011 for the course ENGINEERIN 102 taught by Professor Pablo during the Spring '11 term at Bilkent University.
 Spring '11
 Pablo

Click to edit the document details