binary search tree
Post on 18-Jul-2015
21 Views
Preview:
TRANSCRIPT
Binary tree• A binary tree is composed of zero or more nodes• Each node contains:
– A value (some sort of data item)– A reference or pointer to a left child (may be null), and– A reference or pointer to a right child (may be null)
• A binary tree may be empty (contain no nodes)• If not empty, a binary tree has a root node
– Every node in the binary tree is reachable from the root node by a unique path
• A node with neither a left child nor a right child is called a leaf– In some binary trees, only the leaves contain a value
Size and depth
• The size of a binary tree is the number of nodes in it– This tree has size 12
• The depth of a node is its distance from the root– a is at depth zero– e is at depth 2
• The depth of a binary tree is the depth of its deepest node– This tree has depth 4
a
b c
d e f
g h i j k
l
Binary Tree Example: Expression Trees
• Leaves are operands (constants or variables)• The internal nodes contain operators• Will not be a binary tree if some operators are not
binary
Tree Traversal (Definition)
• The process of systematically visiting all the nodes in a tree and performing some computation at each node in the tree is called a tree traversal.
• There are two methods in which to traverse a tree:1. Breadth-First Traversal.2. Depth-First Traversal:
• Preorder traversal• Inorder traversal (for binary trees only)• Postorder traversal
Tree Traversal Methods
• Pre-order1. Visit node // first2. Recursively visit left subtree3. Recursively visit right subtree
• In-order1. Recursively visit left subtree2. Visit node // second3. Recursively right subtree
• Post-order1. Recursively visit left subtree2. Recursively visit right subtree3. Visit node // last
Depth-first Inorder Traversal
H
D
B
A C E G I K M O
N
L
JF
L-N-R
A B C D E F G H I J K L M N ONote: An inorder traversal of a BST visits the keys sorted in increasing order.
Tree Traversal Methods
• Breadth-first
BFS(Node n) {Queue Q = new Queue();Q.enqueue(n); // insert node into Q while ( !Q.empty()) { n = Q.dequeue(); // remove next node if ( !n.isEmpty()) { visit(n); // visit node Q.enqueue(n.Left()); // insert left subtree in Q Q.enqueue(n.Right()); // insert right subtree in Q
} }
Tree Traversal Examples
• Pre-order (prefix)– + × 2 3 / 8 4
• In-order (infix)– 2 × 3 + 8 / 4
• Post-order (postfix)– 2 3 × 8 4 / +
• Breadth-first– + × / 2 3 8 4
+
× /
2 3 8 4
Expression tree
Tree Traversal Examples• Pre-order
– 44, 17, 32, 78, 50, 48, 62, 88
• In-order– 17, 32, 44, 48,
50, 62, 78, 88
• Post-order– 32, 17, 48, 62,
50, 88, 78, 44
• Breadth-first– 44, 17, 78, 32,
50, 88, 48, 62
88
44
17 78
32 50
48 62
Binary search tree
Sorted order!
Binary Tree Sort• The Binary Tree Sort works on a simple concept: The value at the root of a tree is always greater than all the values in its left subtree and less than or equal to all the values in its right subtree.
• We can search for a value by comparing that value to the root, and if the value is smaller, examine the left subtree, and if the value is larger examine the right subtree.
Binary Tree Sort• Of course, if the values are equal, you've found it!
•The maximum number of comparisons is directly related to the height of the tree.
• But in a tree of height 20 (at most 20 comparisons) we might have 220 or about a million items!
Binary Tree Sort• The first step, then, is to take all the values and build a binary search tree.
• The basis of this process is a function to insert a new value into an existing binary search tree.
left subtree exists?
YES NO
attach value as a left subtree
try the left subtree
Binary Tree Sort
value < value at root?
NOYES
right subtree exists?
YES NO
attach value as a right subtree
try the right subtree
Value must be in the left subtree
Value must be in the right subtree
Binary Search Trees (BST)• A data structure for efficient searching,
inser-tion and deletion
• Binary search tree property– For every node X– All the keys in its left
subtree are smaller than the key value in X
– All the keys in its right subtree are larger than the key value in X
TREE-SEARCH (x, k)if (x== NIL) || (k == key[x])
return xif (k < key[x])
return TREE-SEARCH(left[x], k)else
return TREE-SEARCH(right[x], k)
ITERATIVE-TREE-SEARCH(x, k)
while (x != NIL) && (k != key[x])
if k < key[x]
x = left[x]
else x = right[x]
return x
TREE-MINIMUM (x)while left[x] != NIL
x = left[x]return x
TREE-MAXIMUM(x)while right[x] != NIL
x = right[x]return x
TREE-SUCCESSOR(x)if (right[x] != NIL)
return TREE-MINIMUM (right[x])y = p[x]while (y != NIL) && (x == right[y])
x = yy = p[y]
return y
Insertion• Proceed down the tree as you would with a find• If X is found, do nothing (or update something)• Otherwise, insert X at the last spot on the path
traversed
• Time complexity = O(height of the tree)
TREE-INSERT(T, z)y = NILx = root[T]while (x != NIL)
y = xif (key[z] < key[x])
x = left[x]else x = right[x]
p[z] = yif (y == NIL)
root[T] = z // Tree T was emptyelse if (key[z] < key[y])
left[y] = zelse right[y] = z
Deletion• When we delete a node, we need to
consider how we take care of the children of the deleted node.– This has to be done such that the property of
the search tree is maintained.
Deletion under Different Cases• Case 1: the node is a leaf
– Delete it immediately
• Case 2: the node has one child– Adjust a pointer from the parent to bypass
that node
Deletion Case 3• Case 3: the node has 2 children
– Replace the key of that node with the minimum element at the right subtree
– Delete that minimum element • Has either no child or only right child because if it has a
left child, that left child would be smaller and would have been chosen. So invoke case 1 or 2.
• Time complexity = O(height of the tree)
TREE-DELETE(T, z)if (left[z] == NIL) || (right[z] == NIL)
y = zelse y = TREE-SUCCESSOR(z)if (left[y] != NIL)
x = left[y]else x = right[y]if (x != NIL)
p[x] = p[y]if (p[y] == NIL)
root[T] = xelse if (y == left[p[y]])
left[p[y]] = xelse right[p[y]] = xif (y != z)
key[z] = key[y]copy y's satellite data into z
return y
Threaded Binary Trees
• Too many null pointers in current representationof binary trees n: number of nodes number of non-null links: n-1 total links: 2n null links: 2n-(n-1)=n+1
• Replace these null pointers with some useful “threads”.
Threaded Binary Trees (Continued)
If ptr->left_child is null, replace it with a pointer to the node that would be visited before ptr in an inorder traversal
If ptr->right_child is null, replace it with a pointer to the node that would be visited after ptr in an inorder traversal
A Threaded Binary Tree
A
B C
GE
I
D
H
F
root
dangling
dangling
inorder traversal:H, D, I, B, E, A, F, C, G
Element of the node
(inorder traversal only use successor)
Left predecessor key successor rightLeft predecessor key successor right
Threaded Binary TreesGiven a binary tree with n nodes, the total number of links in the tree is 2n.
Each node (except the root) has exactly one incoming arc only n - 1 links point to nodes remaining n + 1 links are null.
One can use these null links to simplify some traversal processes.
A threaded binary search tree is a BST with unused links employed topoint to other tree nodes. Traversals (as well as other operations, such as backtracking)
made more efficient.
A BST can be threaded with respect to inorder, preorder or postordersuccessors.
Threaded Binary TreesGiven the following BST, thread it to facilitate inorder traversal:
The first node visited in an inorder traversal is the leftmost leaf, node A.
Since A has no right child, the next node visited in this traversal is itsparent, node B.
Use the right pointer of node A as a thread to parent B to make backtrackingeasy.
H
E
B
K
F J L
A D M
C
IG
Threaded Binary Trees
The thread from A to B is shown as the arrow in above diagram.
H
E
B
K
F J L
A D M
C
IG
Threaded Binary TreesThe next node visited is C, and since its right pointer is null, it also can beused as a thread to its parent D:
H
E
B
K
F J L
A D M
C
IG
Threaded Binary TreesNode D has a null right pointer which can be replaced with a pointer to D’sinorder successor, node E:
H
E
B
K
F J L
A D M
C
IG
Threaded Binary TreesThe next node visited with a null right pointer is G. Replace the null pointerwith the address of G’s inorder successor: H
H
E
B
K
F J L
A D M
C
IG
Threaded Binary TreesFinally, we replace:
first, the null right pointer of I with a pointer to its parentand then, likewise, the null right pointer of J with a pointer to its parent
H
E
B
K
F J L
A D M
C
IG
Algorithm to right-thread BSTPerform an inorder traversal of the BST.
Whenever a node x with a null right pointer encountered replace this right link with a thread to the inorder successorof x.
If x is a left child of S then S is the inorder successor of x.
If x is not a left child, then the inorder successor S of x isthe nearest ancestor S of x that contains x in its left subtree.
Algorithm to right-thread BST1. Initialize a pointer p to the root of the tree.
2. While (p) // p is not null:
a. While (p-> left) is not null,p = p-> left .
b. Visit the node pointed to by p.
c. While p->right is a thread do:i. p = p->right.ii. Visit the node pointed to by p.
d. p = p->right.
Must be able to distinguish between right links that are threads and thosethat are pointers to right children add a boolean field rightThread in the node declaration
Algorithm to right-thread BSTclass BinNode{ public:
DataType data;bool rightThread;BinNode *left,
*right;
BinNode (){
rightThread = false; // reset when tree threadedleft = right = 0;
}
BinNode (DataType item){
data = item;rightThread = false; // reset when tree threadedleft = right = 0;
}};// end of class BinNode declaration
top related