Chapter%205Trees - PowerPoint PPT Presentation

View by Category
About This Presentation
Title:

Chapter%205Trees

Description:

Binary Search Trees (5.7) Outline (2) Selection Trees (5.8) Forests (5.9) ... The ancestry of modern Europe languages. The Definition of Tree (1) ... – PowerPoint PPT presentation

Number of Views:37
Avg rating:3.0/5.0
Slides: 111
Provided by: bai54
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Chapter%205Trees


1
Chapter 5 Trees
Instructors C. Y. Tang and J. S. Roger Jang
All the material are integrated from the textbook
"Fundamentals of Data Structures in C" and  some
supplement from the slides of Prof. Hsin-Hsi Chen
(NTU).
2
Outline (1)
  • Introduction (5.1)
  • Binary Trees (5.2)
  • Binary Tree Traversals (5.3)
  • Additional Binary Tree Operations (5.4)
  • Threaded Binary Trees (5.5)
  • Heaps (5.6) (Chapter 9)
  • Binary Search Trees (5.7)

3
Outline (2)
  • Selection Trees (5.8)
  • Forests (5.9)
  • Set Representation (5.10)
  • Counting Binary Trees (5.11)
  • References Exercises

4
5.1 Introduction
  • What is a Tree?
  • For Example
  • Figure 5.1 (a)
  • An ancestor binary tree
  • Figure 5.1 (b)
  • The ancestry of modern Europe languages

5
The Definition of Tree (1)
  • A tree is a finite set of one or more nodes such
    that
  • (1) There is a specially designated node called
    the root.
  • (2) The remaining nodes are partitioned into n
    0 disjoint sets T1, , Tn, where each of these
    sets is a tree.We call T1, , Tn, the sub-trees
    of the root.

root

T1
T2
Tn
6
The Definition of Tree (2)
  • The root of this tree is node A. (Fig. 5.2)
  • Definitions
  • Parent (A)
  • Children (E, F)
  • Siblings (C, D)
  • Root (A)
  • Leaf / Leaves
  • K, L, F, G, M, I, J

7
The Definition of Tree (3)
  • The degree of a node is the number of sub-trees
    of the node.
  • The level of a node
  • Initially letting the root be at level one
  • For all other nodes, the level is the level of
    the nodes parent plus one.
  • The height or depth of a tree is the maximum
    level of any node in the tree.

8
Representation of Trees (1)
  • List Representation
  • The root comes first, followed by a list of
    sub-trees
  • Example (A(B(E(K,L),F),C(G),D(H(M),I, J)))

data
link 1
link 2
...
link n
A node must have a varying number of link fields
depending on the number of branches
9
Representation of Trees (2)
  • Left Child-Right Sibling Representation
  • Fig.5.5
  • A Degree Two Tree
  • Rotate clockwise by 45
  • A Binary Tree

10
5.2 Binary Trees
  • 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 sub-tree
    and the right sub-tree.
  • Any tree can be transformed into a binary tree.
  • By using left child-right sibling representation
  • The left and right subtrees are distinguished

root
The leftsub-tree
The rightsub-tree
11
Abstract Data Type Binary_Tree (structure 5.1)
  • Structure Binary_Tree (abbreviated BinTree) is
  • Objects a finite set of nodes either empty or
    consisting of a root node, left Binary_Tree, and
    right Binary_Tree.
  • Functions
  • For all bt, bt1, bt2 ? BinTree, item ? element
  • Bintree Create() creates an empty binary tree
  • Boolean IsEmpty(bt) if (btempty binary
    tree) return TRUE else return FALSE

12
  • BinTree MakeBT(bt1, item, bt2) return a binary
    tree
  • whose left subtree is bt1, whose right subtree
    is bt2,
  • and whose root node contains the data item
  • Bintree Lchild(bt) if (IsEmpty(bt)) return
    error else return
    the left subtree of bt
  • element Data(bt) if (IsEmpty(bt)) return
    error else return the data in the
    root node of bt
  • Bintree Rchild(bt) if (IsEmpty(bt)) return
    error else return the right
    subtree of bt

13
Special Binary Trees
  • Skewed Binary Trees
  • Fig.5.9 (a)
  • Complete Binary Trees
  • Fig.5.9 (b)
  • This will be defined shortly

14
Properties of Binary Trees (1)
  • Lemma 5.1 Maximum number of nodes
  • (1) The maximum number of nodes on level i of a
    binary tree is 2i -1, i 1.
  • (2) The maximum number of nodes in a binary tree
    of depth k is is 2k -1, k 1.
  • The proof is by induction on i.
  • Lemma 5.2
  • For any nonempty binary tree, T, if n0 is the
    number of leaf nodes and n2 the number of nodes
    of degree 2, then n0 n2 1.

15
Properties of Binary Trees (2)
  • A full binary tree of depth k is a binary tree of
    depth k having 2k -1 nodes, k ? 0.
  • A binary tree with n nodes and depth k is
    complete iff its nodes correspond to the nodes
    numbered from 1 to n in the full binary tree of
    depth k.

16
Binary Tree Representation
  • Array Representation (Fig. 5.11)
  • Linked Representation (Fig. 5.13)

17
Array Representation
  • Lemma 5.3 If a complete binary tree with n
    nodes (depth log2n 1) is represented
    sequentially, then for any node with index i, 1
    ? i ? n, we have
  • (1) parent (i) is at i / 2 , i ? 1.
  • (2) left-child (i) is 2i, if 2i n.
  • (3) right-child (i) is 2i1, if 2i1 n.
  • For complete binary trees, this representation is
    ideal since it wastes no space. However, for the
    skewed tree, less than half of the array is
    utilized.

18
Linked Representation
  • typedef struct node tree_pointer
  • typedef struct node
  • int data
  • tree_pointer left_child, right_child

19
5.3 Binary Tree Traversals
  • Traversing order L, V, R
  • L moving left
  • V visiting the node
  • R moving right
  • Inorder Traversal LVR
  • Preorder Traversal VLR
  • Postorder Traversal LRV

20
For Example
  • Inorder Traversal A / B C D E
  • Preorder Traversal / A B C D E
  • Postorder Traversal A B / C D E

21
Inorder Traversal (1)
  • A recursive function starting from the root
  • Move left ?Visit node ?Move right

22
Inorder Traversal (2)
  • In-order Traversal A / B C D E

23
Preorder Traversal
  • A recursive function starting from the root
  • Visit node ?Move left ? Move right

24
Postorder Traversal
  • A recursive function starting from the root
  • Move left ?Move right ?Visit node

25
Other Traversals
  • Iterative Inorder Traversal
  • Using a stack to simulate recursion
  • Time Complexity O(n), n is num of node.
  • Level Order Traversal
  • Visiting at each new level from the left-most
    node to the right-most
  • Using Data Structure Queue

26
Iterative In-order Traversal (1)
27
Iterative In-order Traversal (2)
Delete C Print Delete Print Add
D Delete D Print Delete Print Add
E Delete E Print
  • Add in stack
  • Add
  • Add
  • Add /
  • Add A
  • Delete A Print
  • Delete / Print
  • Add B
  • Delete B Print
  • Delete Print
  • Add C

In-order Traversal A / B C D E
28
Level Order Traversal (1)
29
Level Order Traversal (2)
  • Add in Queue
  • Deleteq
  • Addq
  • Addq E
  • Deleteq
  • Addq
  • Addq D
  • Deleteq E
  • Deleteq

Addq / Addq C Deleteq D Deleteq / Addq
A Addq B Deleteq C Deleteq A Deleteq B
Level-order Traversal E D / C A B
30
5.4 Additional Binary Tree Operations
  • Copying Binary Trees
  • Program 5.6
  • Testing for Equality of Binary Trees
  • Program 5.7
  • The Satisfiability Problem (SAT)

31
Copying Binary Trees
  • Modified from postorder traversal program

32
Testing for Equality of Binary Trees
  • Equality 2 binary trees having identical
    topology and data are said to be equivalent.

33
SAT Problem (1)
  • Formulas
  • Variables X1, X2, , Xn
  • Two possible values True or False
  • Operators And (?), Or (?), Not (?)
  • A variable is an expression.
  • If x and y are expressions,then ? x, x ? y, x ?y
    are expressions.
  • Parentheses can be used to alter the normal order
    of evaluation,which is ? before ? before ?.

34
SAT Problem (2)
35
SAT Problem (3)
  • The SAT problem
  • Is there an assignment of values to the variables
    that causes the value of the expression to be
    true?
  • For n variables, there are 2n possible
    combinations of true and false.
  • The algorithm takes O(g 2n) time
  • g is the time required to substitute the true and
    false values for variables and to evaluate the
    expression.

36
SAT Problem (4)
  • Node Data Structure for SAT in C

37
SAT Problem (5)
  • A Enumerated Algorithm
  • Time Complexity O (2n)

38
SAT Problem (6)
  • void post_order_eval(tree_pointer node)
  • if (node)
  • post_order_eval(node-gtleft_child)
  • post_order_eval(node-gtright_child)
  • switch(node-gtdata)
  • case not node-gtvalue!node-gtright_child-gtva
    lue
  • break
  • case and node-gtvaluenode-gtright_child-gtval
    ue
  • node-gtleft_child-gtvalue break
  • case or node-gtvaluenode-gtright_child-gtvalu
    e
  • node-gtleft_child-gtvalue break
  • case true node-gtvalueTRUE break
  • case false node-gtvalueFALSE break

39
5.5 Threaded Binary Trees (1)
  • Linked Representation of Binary Tree
  • more null links than actual pointers (waste!)
  • Threaded Binary Tree
  • Make use of these null links
  • Threads
  • Replace the null links by pointers (called
    threads)
  • If ptr -gt left_thread TRUE
  • Then ptr -gt left_child is a thread (to the node
    before ptr)
  • Else ptr -gt left_child is a pointer to left child
  • If ptr -gt right_thread TRUE
  • Then ptr -gt right_child is a thread (to the node
    after ptr)
  • Else ptr -gt right_child is a pointer to right
    child

40
5.5 Threaded Binary Trees (2)
  • typedef struct threaded_tree threaded_pointer
  • typedef struct threaded_tree
  • short int left_thread
  • threaded_pointer left_child
  • char data
  • short int right_child
  • threaded_pointer right_child

41
5.5 Threaded Binary Trees (3)
Head node of the tree
Actual tree
42
Inorder Traversal of a Threaded Binary Tree (1)
  • Threads simplify inorder traversal algorithm
  • An easy O(n) algorithm (Program 5.11.)
  • For any node, ptr, in a threaded binary tree
  • If ptr -gt right_thread TRUE
  • The inorder successor of ptr ptr -gt right_child
  • Else (Otherwise, ptr -gt right_thread FALSE)
  • Follow a path of left_child links from the
    right_child of ptr until finding a node with
    left_Thread TRUE
  • Function insucc (Program 5.10.)
  • Finds the inorder successor of any node (without
    using a stack)

43
Inorder Traversal of a Threaded Binary Tree (2)
44
Inorder Traversal of a Threaded Binary Tree (2)
45
Inserting a Node into a Threaded Binary Tree
  • Insert a new node as a child of a parent node
  • Insert as a left child (left as an exercise)
  • Insert as a right child (see examples 1 and 2)
  • Is the original child node an empty subtree?
  • Empty child node (parent -gt child_thread TRUE)
  • See example 1
  • Non-empty child node (parent -gt child_thread
    FALSE)
  • See example 2

46
Inserting a node as the right child of the parent
node (empty case)
  • parent(B) -gt right_thread FALSE
  • child(D) -gt left_thread right_thread TURE
  • child -gt left_child parent
  • child -gt right_child parent -gt right_child
  • parent -gt right_child child

(1)
(3)
(2)
47
Inserting a node as the right child of the parent
node (non-empty case)
(3)
(1)
(2)
(4)
48
Right insertion in a threaded binary tree
  • void insert_right(threaded_pointer parent,
  • threaded_pointer child)
  • threaded_pointer temp
  • child-gtright_child parent-gtright_child
  • child-gtright_thread parent-gtright_thread
  • child-gtleft_child parent
  • child-gtleft_thread TRUE
  • parent-gtright_child child
  • parent-gtright_thread FALSE
  • If (!child-gtright_thread)/non-empty child/
  • temp insucc(child)
  • temp-gtleft_child child

(1)
(2)
(3)
(4)
49
5.6 Heaps
  • An application of complete binary tree
  • Definition
  • A max (or min) tree
  • a tree in which the key value in each node is no
    smaller (or greater) than the key values in its
    children (if any).
  • A max (or min) heap
  • a max (or min) complete binary tree

A max heap
50
Heap Operations
  • Creation of an empty heap
  • PS. To build a Heap ? O( n log n )
  • Insertion of a new element into the heap
  • O (log2n)
  • Deletion of the largest element from the (max)
    heap
  • O (log2n)
  • Application of Heap
  • Priority Queues

51
Insertion into a Max Heap (1)
(Figure 5.28)
52
Insertion into a Max Heap (2)
void insert_max_heap(element item, int n)
int i if (HEAP_FULL(n)) fprintf(stderr,
the heap is full.\n) exit(1) i
(n) while ((i!1) (item.keygtheapi/2.key
)) heapi heapi/2 i / 2
heapi item
  • the height of n node heap log2(n1)
  • Time complexity O (height) O (log2n)

53
Deletion from a Max Heap
  • Delete the max (root) from a max heap
  • Step 1 Remove the root
  • Step 2 Replace the last element to the root
  • Step 3 Heapify (Reestablish the heap)

54
Delete_max_heap (1)
element delete_max_heap(int n) int parent,
child element item, temp if (HEAP_EMPTY(n))
fprintf(stderr, The heap is empty\n)
exit(1) / save value of the element with
the highest key
/ item heap1 / use last element in
heap to adjust heap / temp heap(n)--
55
Delete_max_heap (2)
parent 1 child 2 while (child lt n)
/ find the larger child of the current
parent / if
((child lt n) (heapchild.keyltheapchi
ld1.key)) child if (temp.key gt
heapchild.key) break / move to the next
lower level / heapparent heapchild
child 2 heapparent temp return
item
56
5.7 Binary Search Trees
  • Heap search / delete arbitrary element
  • O(n) time
  • Binary Search Trees (BST)
  • Searching ? O(h), h is the height of BST
  • Insertion ? O(h)
  • Deletion ? O(h)
  • Can be done quickly by both key value and rank

57
Definition
  • A binary search tree is a binary tree, that may
    be empty or satisfies the following properties
  • (1) every element has a unique key.
  • (23) The keys in a nonempty left(/right)
    sub-tree must be smaller(/larger) than the key in
    the root of the sub-tree.
  • (4) The left and right sub-trees are also binary
    search trees.

58
Searching a BST (1)
59
Searching a BST (2)
  • Time Complexity
  • search ? O(h), h is the height of BST.
  • search2 ? O(h)

60
Inserting into a BST (1)
  • Step 1 Check if the inserting key is different
    from those of existing elements
  • Run search function ? O(h)
  • Step 2 Run insert_node function
  • Program 5.17 ? O(h)

61
Inserting into a BST (2)
void insert_node(tree_pointer node, int num)
tree_pointer ptr, temp modified_search(node,
num) if (temp !(node)) ptr
(tree_pointer) malloc(sizeof(node)) if
(IS_FULL(ptr)) fprintf(stderr, The
memory is full\n) exit(1) ptr-gtdata
num ptr-gtleft_child ptr-gtright_child
NULL if (node) if (numlttemp-gtdata)
temp-gtleft_childptr else
temp-gtright_child ptr else node ptr

62
Deletion from a BST
  • Delete a non-leaf node with two children
  • Replace the largest element in its left sub-tree
  • Or Replace the smallest element in its right
    sub-tree
  • Recursively to the leaf ? O(h)

63
Height of a BST
  • The Height of the binary search tree is O(log2n),
    on the average.
  • Worst case (skewed) ? O(h) O(n)
  • Balanced Search Trees
  • With a worst case height of O(log2n)
  • AVL Trees, 2-3 Trees, Red-Black Trees
  • Chapter 10

64
5.8 Selection Trees
  • Application Problem
  • Merge k ordered sequences into a single ordered
    sequence
  • Definition A run is an ordered sequence
  • Build a k-run Selection tree

65
(No Transcript)
66
Time Complexity
  • Selection Trees Level ? log2k 1
  • Each time to restructure the tree
  • O(log2k)
  • Total time to merge n records
  • O(n log2k)

67
For Example
68
Tree of losers
  • The previous selection tree is called a winner
    tree
  • Each node records the winner of the two children
  • Loser Tree
  • Leaf nodes represent the first record in each run
  • Each non-leaf node retains a pointer to the loser
  • Overall winner is stored in the additional node,
    node 0
  • Each newly inserted record is now compared with
    its parent (not its sibling) ? loser stays,
    winner goes up without storing.
  • Slightly faster than winner trees

69
Loser tree example
overall winner
8
6
9
9
15
15
Run 1 2 3 4
5 6 7 8
15
15
Figure 5.36 Tree of losers corresponding to
Figure 5.34 (p.235)
70
5.9 Forests
  • A forest is a set of n ? 0 disjoint trees.
  • T1, , Tn is a forest of trees
  • Transforming a forest into a Binary TreeB(T1, ,
    Tn)
  • (1) if n 0, then return empty
  • (2) a root (T1)
  • Left sub-tree equal to B(T11,T12, , T1m), where
    T11,T12, , T1m are the sub-trees of root (T1)
  • Right sub-tree B(T2, , Tn)

71
Transforming a forest into a Binary Tree
Root(T1)
T11,T12, T13
B(T2, T3)
72
Forest Traversals
  • Pre-order
  • In-order
  • Post-order

73
5.10 Set Representation
  • Elements 0, 1, , n -1.
  • Sets S1, S2, , Sm
  • pairwise disjoint
  • If Si and Sj are two sets and i ? j, then there
    is no element that is in both Si and Sj.
  • Operations
  • Disjoint Set Union
  • Ex S1 ? S2
  • Find (i )

74
Union Operation
  • Disjoint Set Union
  • S1 ? S2 0, 6, 7, 8, 1, 4, 9

75
Implement of Data Structure
76
Union Find Operation
  • Union(i, j)
  • parent(i) j ? let i be the new root of j
  • Find(i)
  • While (parenti?0)
  • i parenti ? find the root of the set
  • Return i ? return the root of the set

77
Performance
  • Run a sequence of union-find operations
  • Total n-1 unions ? n-1 times, O(n)
  • Time of Finds ? Sni2 i O(n 2)

78
Weighting rule for union(i, j)
  • If of nodes in i lt of nodes in j
  • Then j becomes the parent of i
  • Else i becomes the parent of j

79
New Union Function
  • Prevent the tree from growing too high
  • To avoid the creation of degenerate trees
  • No node in T has level greater than ?log2n? 1

void union2(int i, int j) int temp
parentiparentj if (parentigtparentj)
parentij parentjtemp
else parentji parentitemp

80
Figure 5.45 Trees achieving worst case bound
(p.245)
81
Collapsing Rule (for new find function)
  • Definition If j is a node on the path from i to
    its root then make j a child of the root
  • The new find function (see next slide)
  • Roughly doubles the time for an individual find
  • Reduces the worse case time over a sequence of
    finds.

82
New Find Function
  • Collapse all nodes form i to root
  • To lower the height of tree

83
Performance of New Algorithm
  • Let T(m, n) be the maximum time required to
    process an intermixed sequence of m finds (m?n)
    and n -1 unions, we have
  • k1ma(m, n) ? T(m, n) ? k2ma(m, n)
  • k1, k2 some positive constants
  • a(m, n) is a very slowly growing function and is
    a functional inverse of Ackermanns function A(p,
    q).
  • Function A(p, q) is a very rapidly growing
    function.

84
Equivalence Classes
  • Using union-find algorithms to processing the
    equivalence pairs of Section 4.6 (p.167)
  • At most time O(ma(2m, n))
  • Using less space

85
5.11 Counting Binary Trees
  • Three disparate problems
  • Having the same solution
  • Determine the number of distinct binary trees
    having n nodes (problem 1)
  • Determine the number of distinct permutations of
    the numbers from 1 to n obtainable by a stack
    (problem 2)
  • Determine the number of distinct ways of multiply
    n 1 matrices (problem 3)

86
Distinct binary trees
  • N 1
  • only one binary tree
  • N 2
  • 2 distinct binary trees
  • N 3
  • 5 distinct binary trees
  • N

87
Stack Permutations (1)
  • A binary tree traversals
  • Pre-order A B C D E F G H I
  • In-order B C A E D G H F I
  • Is this binary tree unique?
  • Constructing this binary tree

88
Stack Permutations (2)
  • For a given preorder permutation 1, 2, 3, what
    are the possible inorder permutations?
  • Possible inorder permutation by a stack ?
  • (1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3,
    2, 1)
  • (3, 1, 2) is impossible
  • Each inorder permutation represents a distinct
    binary tree

89
Matrix Multiplication (1)
  • The product of n matrices
  • M1 M2 Mn
  • Matrix multiplication is associative
  • Can be performed in any order
  • N 3, 2 ways to perform
  • (M1 M2) M3
  • M1 (M2 M3)
  • N 4, 5 possibilities

90
Matrix Multiplication (2)
  • Let bn be the number of different ways to compute
    the product of n matrices.
  • We have

91
number of distinct binary trees
  • Approximation by solving the recurrence of the
    equation

Solution (when x ?8)
?
?
?
?
Simplification
Approximation
92
HeapsortAn optimal sorting algorithm
  • A heap parent ? son

93
  • output the maximum and restore
  • Heapsort construction
  • output

94
Phase 1 construction
  • restore the subtree rooted at A(2)
  • restore the tree rooted at A(1)
  • input data 4, 37, 26, 15, 48

95
Phase 2 output
96
Implementation
  • using a linear array
  • not a binary tree.
  • The sons of A(h) are A(2h) and A(2h1).
  • time complexity O(n log n)

97
Time complexityPhase 1 construction
98
Time complexity Phase 2 output
99
??4????????
100
??????????????????????
101
???????Traveling Salesman Problem
(TSP)?????(1)??,??(1)?????
12
1
2
1
8
3
2
10
3
4
102
TSP????????NP-Complete
  • ???????????????????????
  • ?????????????
  • Ref Horowitz Sahni,Fundamentals of Computer
    Algorithms, P528.

103
  • 2n????

10 30 50
N 0.00001 s 0.00003 s 0.00005 s
N2 0.0001 s 0.0009 s 0.0025 s
2n 0.001 s 17.9 min 35.7 year
  • ?satisfiabilibility problem
  • ????exponential algorithm,??????polynomial
    algorithm (??????!)??????NP-Complete Problem
  • Garey Johnson Computers Intractability

104
???(Enumerating)
  • (?????????????)
  • ???????
  • 3!?? (n-1)!
  • ???????
  • 16?? n(n-2) Cayleys Thm.
  • Ref Even, Graph Algorithms, PP2628

2
1
1
4
3
12
4
105
  • Labeled tree ? Number sequenceOne-to-One Mapping
  • N?nodes?labeled tree???????N-2?number
    sequence????
  • Encoding Data Compression.

106
Labeled tree?Number sequence
  • ????iteration?,??????leaves??????node??edges,????
    ,??????edge???
  • ?.
  • Prune-sequence7,4,4,7,5(??)
  • Label????????edge.
  • ??node???degree??node?Prune-sqeuence??????1.

2
5
6
4
7
3
1
107
Number sequence?Labeled tree
  • Prune-sequence 7,4,4,7,5

k 1 2 3 4 5 6 7
deg(k) 1 1 1 3 2 1 3
Iteration 1 0 1 1 3 2 1 2
Iteration 2 0 0 1 2 2 1 2
Iteration 3 0 0 0 1 2 1 2
Iteration 4 0 0 0 0 2 1 1
Iteration 5 0 0 0 0 1 0 1
Iteration 6 0 0 0 0 0 0 0
  • ???iteration?,??degree?1??????node,??prune-sequenc
    e????node,????nodes?degree??1.
  • Iteration 1 Iteration 2
  • Iteration 3
  • Iteration 4 Iteration 6
  • Iteration 5

1
7
1
7
2
4
1
7
2
4
3
3
1
7
4
3
1
7
4
2
2
3
5
1
7
4
6
5
2
6
108
Minimal spanning treeKruskala Algorithm
A
B
70
C
300
50
75
80
65
200
D
E
90
Begin T lt- null While T contains less
than n-1 edges, the smallest weight,
choose an edge (v, w) form E of smallest weight ?
Using priority queue, heap ?O (log n) ?,
delete (v, w) form E. If the adding of
(v, w) to T does not create a cycle in T,? Using
union, find ?O (log m)? then add (v, w)
to T else discard (v, w).
Repeat. End. O (m log m) m of edge
109
?priority queue???heap operation
1
2
4
  • O(log n)
  • Initial O(n)
  • Tarjan Union Find??almost linear (Amortized)
  • Correctness
  • ??????edge?tree???minimal
  • ????edge??cycle
  • Delete cycle????edge?????cost?tree ??(??!)

3
7
5
6
110
?spanning tree????spanning forest?link
  • 1. ? edge(2,3) ???
  • 2. ? edge(1,4) ??
  • ?????
  • S11,2,3
  • S24,5
  • Edge???????set
  • Set? Find, Union O(log n)

1
4
3
2
5
About PowerShow.com