Transcript Document
Chap 5 Trees
Trees
• Definition: A tree is a finite set of one or more nodes such that: – There is a specially designated node called the root.
– The remaining nodes are partitioned into n ≥ 0 disjoint sets T 1 , …, T n , where each of these sets is a tree. We call T 1 , …, T n the subtrees of the root.
Pedigree Genealogical Chart
Cheryl John Kevin Terry Richard Rosemary Kelly Jack Mary Anthony Karen Joe Michelle Mike
Binary Tree
Angela
Lineal Genealogical Chart
Osco-Umbrian Italic Proto Indo-European Hellenic Germanic Latin Greek North Germanic West Germanic Osco Umbrian Spanish French Italian Icelandic Norwegian SwedishLow High Yiddish
Tree Terminology
• Normally we draw a tree with the root at the top.
• The degree of a node is the number of subtrees of the node.
• The degree of a tree is the maximum degree of the nodes in the tree.
• A node with degree zero is a leaf or terminal node.
• A node that has subtrees is the parent of the roots of the subtrees, and the roots of the subtrees are the children of the node.
• Children of the same parents are called siblings.
Tree Terminology (Cont.)
• The ancestors of a node are all the nodes along the path from the root to the node.
• The descendants of a node are all the nodes that are in its subtrees.
• Assume the root is at level 1, then the level of a node is the level of the node ’ s parent plus one.
• The height or the depth of a tree is the maximum level of any node in the tree.
B E K L F
A Sample Tree
A C G H D I M Level 1 2 J 3 4
List Representation of Trees
The tree in previous slide could be written as (A (B (E (K, L), F), C(G), D(H (M), I, J))) A B E 0 F 0 C K L 0 G 0 D I H M 0 J 0
Possible Node Structure For A Tree of Degree • Lemma 5.1: If T is a k-ary tree (i.e., a tree of degree k) with n nodes, each having a fixed size as in Figure 5.4, then n(k-1) + 1 of the nk child fileds are 0, n ≥ 1.
Data Child 1 Child 2 Child 3 Child 4 … Child k Wasting memory!
Representation of Trees
• Left Child-Right Sibling Representation – Each node has two links (or pointers).
– Each node only has one leftmost child and one closest sibling.
A left child data right sibling B C D E F G H I J K L M
Degree Two Tree Representation
A K E F L B G C D H M I Binary Tree!
J
Tree Representations
B A B A C A B A B C Left child-right sibling A B A B C Binary tree
Binary Tree
• Definition: A binary tree is a finite set of nodes that is either empty or consists of a root and two disjoint binary trees called the left subtree and the right subtree.
• There is no tree with zero nodes. But there is an empty binary tree.
• Binary tree distinguishes between the order of the children while in a tree we do not.
B A B A
Binary Tree Examples
E D C B A A B D H I E F C G
• • •
The Properties of Binary Trees
Lemma 5.2 [Maximum number of nodes] 1) The maximum number of nodes on level i of a binary tree is tree of depth 2 k i-1 , i ≥ 1.
is 2 k – 1, k ≥ 1 .
Lemma 5.3 [Relation between number of leaf nodes and nodes of degree 2]: For number of leaf nodes and nodes, k ≥ 0 .
T n2 of nodes of degree 2, then n 0 n the number = n 2 is a binary tree of depth k having 2 + 1 .
k – 1
Binary Tree Definition
depth k is complete iff its nodes correspond binary tree of depth k.
1 level 1 2 3 2 4 5 6 7 3 8 9 10 11 12 13 14 15 4
Array Representation of A Binary Tree
• Lemma 5.4: If a complete binary tree with
n
nodes is represented sequentially, then for any node with index
i,
1 ≤
i
≤
n
, we have: – parent(
i
i
≠1. If root and has no parent.
– left_child(
i
) is at 2
i
if
2i
≤
n i
= 1 ,
i
is at the . If 2i > n, then i has no left child.
– right_child (
i
) is at 2
i
+ 1 if 2
i
+ 1 ≤
n
. If 2
i
+ 1 >
n
, then
i
has no right child.
• Position zero of the array is not used.
Proof of Lemma 5.4 (2)
Assume that for all left_child (
j
) is at 2
j
.
j
, 1 ≤
j
≤
i
, Then two nodes immediately preceding left_child(
i
+ 1) are the right and left children of
i
. The left child is at 2
i
. Hence, the left child of unless 2(
i
1
i
+ 1 + 1) is at 2
i
>
n
has no left child.
+ 2 = 2(
i
+ 1)
, in which case
i
+
Array Representation of Binary Trees
[1] [2] [3] [4] [5] [6] [7] [8] [9] A B C D [1] [2] [3] [4] [5] [6] [7] [8] [9] F G H I A B C D E [16] E
Linked Representation
class class
Tree; TreeNode {
friend class
Tree;
private
: TreeNode *LeftChild;
char
data; TreeNode *RightChild; };
class
Tree {
public
: // Tree operations .
private
: TreeNode *root; };
Node Representation
data LeftChild RightChild LeftChild data RightChild
Linked List Representation For The Binary Trees root A 0 B 0 C 0 D 0 0 E 0 H 0 D B I 0 E root A F 0 C G 0
Tree Traversal
• When visiting each node of a tree exactly once, this produces a linear order for the node of a tree.
• There are 3 traversals if we adopt the convention that we traverse left before right: LVR (inorder), LRV (postorder), and VLR (preorder).
• When implementing the traversal, a recursion is perfect for the task.
Binary Tree With Arithmetic Expression A / B * C * D + E
Tree Traversal
• Inorder Traversal: A/B*C*D+E => Infix form • Preorder Traversal: +**/ABCDE => Prefix form • Postorder Traversal: AB/C*D*E+ => Postfix form
Inorder traversal
} template
Inorder(root); template
If (currentNode){ Inorder(currentNode->leftChild); Visit(currentNode); Inorder(currentNode->Child); } }
Iterative Inorder Traversal
} void Tree::NonrecInorder() { // nonrecursive inorder traversal using a stack Stack
while
(1) {
while
(CurrentNode) { // move down LeftChild fields s.Add(CurrentNode); // add to stack CurrentNode = CurrentNode->LeftChild; }
if
(!s.IsEmpty()) { // stack is not empty CurrentNode = *s.Delete(CurrentNode);
cout
<< CurrentNode->data << endl; CurrentNode = CurrentNode->RightChild; }
else break
; }
Level-Order Traversal
• All previous mentioned schemes use stacks. • Level-order traversal uses a queue.
• Level-order scheme visit the root first, then the root ’ s left child, followed by the root ’ s right child.
• All the node at a level are visited before moving down to another level.
Level-Order Traversal of A Binary Tree }
void
Tree::LevelOrder() { // Traverse the binary tree in level order Queue
while
(CurrentNode) {
cout
<< CurrentNode->data< if (CurrentNode->LeftChild) q.Add(CurrentNode->LeftChild); if (CurrentNode->RightChild) q.Add(CurrentNode->RightChild); CurrentNode = *q.Delete(); } +*E*D/CAB • Use of parent field to each node. • Use of two bits per node to represents binary trees as threaded binary trees. • With the inorder, postorder, or preorder mechanisms, we can implement all needed binary tree functions. E.g., – Copying Binary Trees – Testing Equality • Two binary trees are equal if their topologies are the same and the information in corresponding nodes is identical. • Expression Rules – A variable is an expression – If x and y are expressions then x y , x y , and x are expressions – Parentheses can be used to alter the normal order of evaluation, which is before and before or . not Propositional Formula In A Binary Tree x 1 x 3 x 2 x 1 x 3 ( x 1 x 2 ) ( x 1 x 3 ) x 3 O( g2 n ) • To evaluate an expression, we can traverse its tree in postorder. • To perform evaluation, we assume each node has four fields – LeftChild – data – value – RightChild LeftChild data value RightChild First Version of Satisfiability Algorithm { For all 2 n possible truth value combinations for the n variables generate the next combination; replace the variables by their values; evaluate the formula by traversing the tree it points to in postorder; if (formula.rootvalue()) {cout << combination; return;} } Cout << “no satisfiable combination”; } { void SatTree::PostOrderEval() // Driver PostOrderEval(root); } { void SatTree::PostOrderEval(SatNode * s) // workhorse if (s) { PostOrderEval(s->LeftChild); PostOrderEval(s->RightChild); switch (s->data) { case LogicalNot: s->value =!s->RightChild->value; break ; case LogicalAnd: s->value = s->LeftChild->value && s->RightChild->value; case break ; LogicalOr: s->value = s->LeftChild->value || s->RightChild->value; case case break ; LogicalTrue: s->value = TRUE; break ; LogicalFalse: s->value = FALSE; } } • Threading Rules – A 0 RightChild field at node p is replaced by a pointer to the node that would be visited after p when traversing the tree in inorder. That is, it is replaced by the inorder successor of p. – A 0 LeftChild link at node p is replaced by a pointer to the node that immediately precedes node p in inorder (i.e., it is replaced by the inorder predecessor of p). Threaded Tree Corresponding to Figure 5.10(b) A B C H D E F G I Inorder sequence: H, D, I, B, E, A, F, C, G • To distinguish between normal pointers and threads, two boolean fields, LeftThread and RightThread, are added to the record in memory representation. – t->LeftChild = TRUE => t->LeftChild is a thread – t->LeftChild = FALSE => t->LeftChild is a pointer to the left child. • To avoid dangling threads, a head node is used in representing a binary tree. • The original tree becomes the left subtree of the head node. • Empty Binary Tree LeftThread LeftChild TRUE data RightChild RightThread FALSE Memory Representation of Threaded Tree of Figure 5.20 f f f A f t H t f D f f B f f B f t E t f D f t E t t I t • By using the threads, we can perform an inorder traversal without making use of a stack. } T* ThreadedInorderIterator::Next() {//Return the inorder successor of currentnode ThreadedNode Inserting A Node to AThreaded Binary Tree • Inserting a node r as the right child of a node s. – If s has an empty right subtree, then the insertion is simple and diagram in Figure 5.23(a). – If the right subtree of s is not empty, the this right subtree is made the right subtree of r after insertion. When thisis done, r becomes the inorder predecessor of a node that has a LdeftThread==TRUE field, and consequently there is an thread which has to be updated to point to r. The node containing this thread was previously the inorder successor of s. Figure 5.23(b) illustrates the insertion for this case. Insertion of r As A Right Child of s in A Threaded Binary Tree s before r s after r Insertion of r As A Right Child of s in A Threaded Binary Tree (Cont.) s r before after s r r Program 5.16 Inserting r As The Right Child of s } { void ThreadedTree::InsertRight(ThreadNode *s, ThreadedNode *r) // Insert r as the right child of s r->RightChild = s->RightChild; r->RightThread = s->RightThread; r->LeftChild = s; r->LeftThread = TRUE; // LeftChild is a thread r->RightChild = r; } if (!r->RightThread) { // attach r to s r->RightThread = FALSE; ThreadedNode *temp = InorderSucc(r); // returns the inorder successor of r temp->LeftChild = r; • In a priority queue, the element to be deleted is the one with highest (or lowest) priority. • An element with arbitrary priority can be inserted into the queue according to its priority. • A data structure supports the above two operations is called max (min) priority queue. • Suppose a server that serve multiple users. Each user may request different amount always select the request with the smallest time. Hence, any new user ’ s is the min priority queue. • If each user needs the same amount of obtain the service quicker, then this is max priority queue. • Unorder Linear List – Addition complexity: O(1) – Deletion complexity: O(n) • Chain – Addition complexity: O(1) – Deletion complexity: O(n) • Ordered List – Addition complexity: O(n) – Deletion complexity: O(1) • Heaps are frequently used to implement priority queues. The complexity is O(log n). • Definition: A max (min) tree is a tree in which the key value in each node is no smaller (larger) than the key values in its children (if any). A max heap is a complete binary tree that is also a max tree. A min heap is a complete binary tree that is also a min tree. 14 12 10 8 6 7 5 9 6 3 15 14 10 20 20 2 15 14 10 1 2 14 15 10 20 2 20 15 14 10 2 15 14 10 20 2 15 14 10 2 } template if (IsEmpty()) throw “Heap is empty.”; heap[1].~T(); //delete max element //remove last element from heap T lastE = heap [heapSize--]; int currentNode = 1; int child = 2; while (child >= leapSize) { if (child < heapSize && heap[child] < heap[child+1]) child++; if (lastE >= heap[child]) break; heap[currentNode] = heap[child]; currentNode = child; } heap[currentNode] = lastE; child *= 2; 21 15 14 10 2 20 14 15 2 10 2 20 15 14 10 2 20 15 14 10 20 2 • Definition: A binary serach tree is a binary tree. It may be empty. If it is not empty then it satisfies the following properties: – Every element has a key and no two elements have the same key (i.e., the keys are distinct) – The keys (if any) in the left subtree are smaller than the key in the root. – The keys (if any) in the right subtree are larger than the key in the root. – The left and right subtrees are also binary search trees. 20 30 60 14 15 25 10 Not binary search tree 22 2 5 40 Binary search trees 70 65 80 • If the root is 0, then this is an empty tree. No search is needed. • If the root is not 0, compare the x with the key of root. – If x equals to the key of the root, then it ’ s done. – If x is less than the key of the root, then no elements in the right subtree can have key value x. We only need to search the left tree. – If x larger than the key of the root, only the right subtree is to be searched. • To search a binary search tree by the ranks of the elements in the tree, we need additional field “ LeftSize by rank in O(h) time. ” . • LeftSize is the number of the elements in the left subtree of a node plus one. • It is obvious that a binary search tree of height h can be searched by key as well as Searching A Binary Search Tree by Rank } { template • Before insertion is performed, a search must be done to make sure that the value to be inserted is not already in the tree. • If the search fails, then we know the value is not in the tree. So it can be inserted into the tree. • It takes O(h) to insert a node to a binary search tree. Inserting Into A Binary Search Tree 2 5 30 40 80 2 5 30 40 35 80 } Insertion Into A Binary Search Tree Template • Delete a leaf node – A leaf node which is a right child of its parent – A leaf node which is a left child of its parent • Delete a non-leaf node – A node that has one child – A node that has two children • Replaced by the largest element in its left subtree, or • Replaced by the smallest element in its right subtree • Again, the delete function has complexity of O(h) 2 5 30 40 35 80 2 25 40 80 2 25 40 80 2 25 40 80 22 40 80 • C.ThreeWayJoin(A, x, B): Creates a binary search tree C that consists of binary search tree A, B, and element x. • C.TwoWayJoin(A, B): Joins two binary search trees A and B to obtain a single binary search tree C. • A.Split(i, B, x, C): Binary search tree A splits into three parts: B (a binary search have key less than i); if A contains a key i than this element is copied into x and a tree that contains all records of A that have key larger than i. 2 5 30 40 35 80 A 81 81 x 90 85 84 B 92 94 30 2 5 40 A 35 80 90 85 84 B 92 94 2 B 5 30 x 40 35 80 A 75 C 81 i = 30 i = 80 2 5 30 t Y L 40 t A 35 75 80 81 t 2 5 30 B 35 40 75 L L 81 C 80 x Z R R • When trying to merge k ordered sequences (assume in non-decreasing order) into a single sequence, the most intuitive way is probably to perform k sequences are visited. – 1 comparison each time to select the smallest one among the first number of each of the k ordered sequences. This goes on until all numbers in every • There should be a better way to do this. • A winner tree is a complete binary tree in which each node represents the smaller of its two children. Thus the root represents the smallest node in the tree. • Each leaf node represents the first record in the corresponding run. • Each non-leaf node in the tree represents the winner of its right and left subtrees. 8 10 15 16 4 9 1 6 9 9 20 38 2 6 10 20 20 30 6 5 6 11 15 25 28 12 8 15 50 6 8 8 3 9 13 11 16 14 90 95 99 17 7 17 15 18 20 run1 run2 run3 run4 run5 run6 run7 run8 8 10 15 16 4 9 1 8 9 9 20 38 2 9 10 20 20 30 15 5 15 11 25 28 12 8 15 50 6 8 8 3 9 13 11 16 14 90 95 99 17 7 17 15 18 20 run1 run2 run3 run4 run5 run6 run7 run8 • The number of levels in the tree is – The time to restructure the winner tree is O( • Since the tree has to be restructured each time a number is output, the time to merge all n records is O( n log 2 k ). the first time is O(k). log 2 ( k log • Total time needed to merge the k runs is O( 2 k 1 ) ). • The time required to setup the selection tree for n log 2 k ). • A selection tree in which each nonleaf node retains a pointer to the loser is called a loser tree. • Again, each leaf node represents the first record of each run. • An additional node, node 0, has been added to represent the overall winner of the tournament. run 10 1 4 10 0 6 1 8 9 9 2 2 9 10 20 3 20 5 6 11 4 12 8 5 6 9 Overall winner 9 6 13 17 3 14 90 7 90 7 17 15 8 run 10 1 4 10 0 8 1 9 9 9 2 2 15 10 20 3 20 5 15 11 4 12 8 5 6 9 Overall winner 9 6 13 17 3 14 90 7 90 7 17 15 8 • Definition: A forest is a set of n ≥ 0 disjoint trees. • When we remove a root from a tree, we ’ ll get a forest. E.g., Removing the root of a binary tree will get a forest of two trees. Transforming A Forest Into A Binary Tree • Definition: If T 1 , …, T then the binary tree corresponding to this forest, denoted by B( n T 1 is a forest of trees, , …, T n ), – is empty if n = 0 – has root equal to root ( T 1 ); has left subtree equal to B( T 11 , T 12, …, T 1m ), where T 11 , T 12, …, T 1m are the subtrees of root ( T 1 ); and has right subtree B( T 2 , …, T n ). • Trees can be used to represent sets. • Disjoint set union: If Si and Sj are two disjoint sets, then their union S i ∪ S i S j = {all elements x such that x is in or S j }. • Find(i). Find the set containing element i. Possible Tree Representation of Sets 0 6 7 S 1 8 1 S 2 4 9 2 3 S 3 5 i ∪ j 0 6 7 8 4 1 9 4 0 6 7 8 1 9 • To obtain the union of two sets, just set the parent field of one of the roots to the other root. • To figure out which set an element is belonged to, just follow its parent link to the root and then follow the pointer in the root to the set name. 1, 2 3 Set Name Pointer S 1 S 2 S 3 6 0 7 8 1 4 9 2 3 5 1, 2 3 • We could use an array for the set name. Or the set name can be an element at the root. • Assume set elements are numbered 0 through n-1. i parent [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] -1 4 -1 2 -1 2 0 0 0 4 • For a set of n elements each in a set of its own, then the result of the union function is a degenerate tree. • The time complexity of the following union-find operation is O(n 2 ). union(0, 1), union(1, 2), … , union(n-2, n-1) find(0), find (1), … , find(n-1) • The complexity can be improved by using weighting rule for union. Union operation O(n) n-1 Find operation O(n 2 ) n-1 n-2 union(0, 1), find(0) union(1, 2), find(0) union(n-2, n-1), find(0) 0 • Definition [Weighting rule for union(I, j)]: If the number of nodes in the tree with root i is less than the number in the tree with root j, then make j the parent of i; otherwise make i the parent of j. Trees Obtained Using The Weighting Rule 0 1 n-1 0 1 2 n-1 1 0 3 2 n-1 0 4 1 2 3 n-1 1 2 3 0 n-1 • Lemma 5.5: Assume that we start with a forest of trees, each having one node. Let T be a tree with m nodes created as a result of a sequence of unions each performed using function WeightedUnion. The height sequence of u f*log u). – log 2 m 1 • For the processing of an intermixed 1 unions and f find operations, the time complexity is O(u + [-1] 0 [-1] 1 [-1] 2 [-1] 3 [-1] 4 [-1] 5 (a) Initial height trees [-1] 6 [-1] 7 [-2] 0 [-2] 2 [-2] 4 [-2] 6 1 3 5 7 (b) Height-2 trees following union (0, 1), (2, 3), (4, 5), and (6, 7) Trees Achieving Worst-Case Bound (Cont.) [-4] 0 [-4] 4 [-8] 0 1 2 5 6 1 2 4 3 7 3 5 6 (c) Height-3 trees following union (0, 2), (4, 6) 7 (d) Height-4 trees following union (0, 4) • Definition [Collapsing rule]: If j is a node on the path from i to its root and parent[i]≠ root(i), then set parent[j] to root(i). • The first run of find operation will collapse the tree. Therefore, all following find operation of the same element only goes up one link to find the root. 1 [-8] 0 2 3 5 4 6 Before collapsing 7 1 [-8] 0 2 4 3 5 After collapsing 6 7 Analysis of WeightedUnion and CollapsingFind • The use of collapsing rule roughly double the time for an individual find. However, it reduces the worst-case time over a sequence of finds. • Lemma 5.6 [Tarjan and Van Leeuwen]: Assume that we start with a forest of trees, each having one node. Let intermixed sequence of f T(f, u) be the maximum time required to process any finds and u unions. Assume that u ≥ n/2 . Then k 1 (n + fα(f + n, n)) ≤ T(f, u) ≤ k 2 (n + fα(f + n, n)) for some positive constants k 1 and k 2 . • The aforementioned techniques can be applied to the equivalence class problem. • Assume initially all n polygons are in an equivalence class of their own: parent[i] = -1, 0 ≤ i < n. – Firstly, we must determine the sets that contains i and j. – If the two are in different set, then the two sets are to be replaced by their union. – If the two are in the same set, then nothing need to be done since they are already in the equivalence class. – So we need to perform two finds and at most one union. • If we have n polygons and m equivalence pairs, we need – O(n) to set up the initial n-tree forest. – 2m finds – at most min{n-1, m} unions. • If weightedUnion and CollapsingFind are used, the time complexity is O(n + m (2m, min{n-1, m})). – This seems to slightly worse than section 4.7 (O(m+n)). But this scheme demands less space. [-1] [-1] [-1] [-1] [-1] [-1] [-1] [-1] 0 1 2 3 4 5 6 7 (a) Initial trees [-1] [-1] [-1] [-1] 8 9 10 11 [-2] 0 [-2] 3 [-2] 6 [-2] 8 [-1] 2 [-1] 5 [-1] 7 [-1] 11 4 1 10 9 (b) Height-2 trees following 0 ≡ 4, 3 ≡ 1, 6 ≡ 10, and 8 ≡ 9 4 4 [-3] 0 7 10 [-4] 6 8 1 [-3] 3 5 [-2] 2 11 9 [-3] 0 [-4] 6 [-3] 3 7 2 11 10 8 9 1 5 • In section 5.3 we introduced preorder, inorder, and postorder traversal of a binary tree. Now suppose we are given a sequence (e.g., inorder sequence BCAEDGHFI), does the sequence uniquely define a binary tree? Constructing A Binary Tree From Its Inorder Sequence A B, C D, E, F, G, H, I A B C D, E, F, G, H, I Constructing A Binary Tree From Its Inorder Sequence (Cont.) 1 A B C E D G F H I 2 4 3 5 6 7 8 Preorder: 1, 2, 3, 4, 5, 6, 7, 8, 9 Inorder: 2, 3, 1, 5, 4, 7, 8, 6, 9 9 1 2 (1, 2, 3) 3 1 2 3 (1, 3, 2) 1 2 3 (2, 1, 3) 1 2 3 (2, 3, 1) 2 3 (3, 2, 1) 1 • The number of distinct binary trees is equal to the number of distinct inorder permutations obtainable from binary trees having the preorder permutation, 1, 2, tree problem. M 1 * M 2 * … * M n … , n. • Computing the product of n matrices are related to the distinct binary n = 3 (M 1 * M 2 ) * M 3 M 1 * (M 2 n = 4 ((M 1 * M 2 ) * M 3 ) * M 4 (M 1 * (M 2 M 1 * ((M 2 (M 1 * (M 2 * M 3 )) * M 4 * M * (M 3 3 ) * M ((M 1 * M 2 ) * (M 3 * M 4 ))) * M 4 4 ) )) * M 3 ) Let bn be the number of different ways to compute the product of n matrices. b 2 = 1, b 3 = 2, and b 4 = 5. b n i 1 n 1 b i b n i , n 1 • The number of distinct binary trees of n nodes is b n b i b n i 1 , n 1 , and b 0 1 b n b i b n-i-1 B ( x ) i 0 b i x function for the number of binary trees. • By the recurrence relation we get xB 2 ( x ) B ( x ) 1 B ( x ) B ( x ) 1 1 4 x 2 x 1 2 x 1 n 0 1 / n 2 ( 4 x ) n m 0 1 m / 2 1 ( 1 ) m 2 2 m 1 x m b n n 1 1 2 n n b n O ( 4 n / n 3 / 2 )Traversal Without A Stack
Some Other Binary Tree Functions
The Satisfiability Problem
Perform Formula Evaluation
Evaluating A Formula
Threaded Binary Tree
Threads
Threads (Cont.)
Finding the inorder successor without stack
Priority Queues
Examples of Priority Queues
Priority Queue Representation
Max (Min) Heap
Max Heap Examples
Insertion Into A Max Heap (1)
Insertion Into A Max Heap (2)
Insertion Into A Max Heap (3)
Deletion From A Max Heap
Deletion From A Max Heap (Cont.)
Deletion From A Max Heap (Cont.)
Binary Search Tree
Binary Trees
Searching A Binary Search Tree
Search Binary Search Tree by Rank
Insertion To A Binary Search Tree
Deletion From A Binary Search Tree
Deleting From A Binary Search Tree
Deleting From A Binary Search Tree
Joining and Splitting Binary Trees
ThreeWayJoin(A, x, B)
TwoWayJoin(A, B)
A.Split(i, B, x, C)
A.Split(i, B, x, C)
Selection Trees
Winner Tree
Winner Tree For k = 8
Winner Tree For k = 8
Analysis of Winner Tree
Loser Tree
Loser Tree
Loser Tree
Forests
Set Representation
Possible Representations of S
S
Unions of Sets
Data Representation for S
S
, S
Array Representation of S
S
, S
Union-Find Operations
Degenerate Tree
Weighting Rule
Weighted Union
Trees Achieving Worst-Case Bound
Collapsing Rule
Collapsing Find
Revisit Equivalence Class
Example 5.5
Example 5.5 (Cont.)
Uniqueness of A Binary Tree
Distinct Binary Trees
Distinct Binary Trees (Cont.)
Distinct Binary Trees (Cont.)
Distinct Binary Trees (Cont.)