Presentation is loading. Please wait.

Presentation is loading. Please wait.

Data Structures and Algorithms Course’s slides: Hierarchical data structures www.mif.vu.lt/~algis.

Similar presentations


Presentation on theme: "Data Structures and Algorithms Course’s slides: Hierarchical data structures www.mif.vu.lt/~algis."— Presentation transcript:

1 Data Structures and Algorithms Course’s slides: Hierarchical data structures

2 Trees  Linear access time of linked lists is prohibitive  Does there exist any simple data structure for which the running time of most operations (search, insert, delete) is O(log N)?

3 Trees  A tree is a collection of nodes  The collection can be empty  (recursive definition) If not empty, a tree consists of a distinguished node r (the root ), and zero or more nonempty subtrees T 1, T 2,...., T k, each of whose roots are connected by a directed edge from r

4 Some Terminologies  Child and parent  Every node except the root has one parent  A node can have an arbitrary number of children  Leaves  Nodes with no children  Sibling  nodes with same parent

5 Some Terminologies  Path  Length  number of edges on the path  Depth of a node  length of the unique path from the root to that node  The depth of a tree is equal to the depth of the deepest leaf  Height of a node  length of the longest path from that node to a leaf  all leaves are at height 0  The height of a tree is equal to the height of the root  Ancestor and descendant  Proper ancestor and proper descendant

6 Example: UNIX Directory

7 Binary Trees  A tree in which no node can have more than two children  The depth of an “ average ” binary tree is considerably smaller than N, eventhough in the worst case, the depth can be as large as N – 1.

8 Example: Expression Trees  Leaves are operands (constants or variables)  The other nodes (internal nodes) contain operators  Will not be a binary tree if some operators are not binary

9 Tree traversal  Used to print out the data in a tree in a certain order  Pre-order traversal  Print the data at the root  Recursively print out all data in the left subtree  Recursively print out all data in the right subtree

10 Preorder, Postorder and Inorder  Preorder traversal  node, left, right  prefix expression  ++a*bc*+*defg

11 Preorder, Postorder and Inorder  Postorder traversal  left, right, node  postfix expression  abc*+de*f+g*+  Inorder traversal  left, node, right.  infix expression  a+b*c+d*e+f*g

12 Preorder, Postorder and Inorder

13 Binary Trees Possible operations on the Binary Tree ADT parent left_child, right_child sibling root, etc Implementation Because a binary tree has at most two children, we can keep direct pointers to them

14 Compare: Implementation of a general tree

15 Binary Search Trees Stores keys in the nodes in a way so that searching, insertion and deletion can be done efficiently. Binary search tree property  For every node X, all the keys in its left subtree are smaller than the key value in X, and all the keys in its right subtree are larger than the key value in X

16 Binary Search Trees A binary search tree Not a binary search tree

17 Binary search trees  Average depth of a node is O(log N); maximum depth of a node is O(N) Two binary search trees representing the same set:

18 Searching BST  If we are searching for 15, then we are done.  If we are searching for a key < 15, then we should search in the left subtree.  If we are searching for a key > 15, then we should search in the right subtree.

19 Inorder traversal of BST  Print out all the keys in sorted order Inorder: 2, 3, 4, 6, 7, 9, 13, 15, 17, 18, 20

20 findMin/findMax Return the node containing the smallest element in the tree Start at the root and go left as long as there is a left child. The stopping point is the smallest element Similarly for findMax Time complexity = O(height of the tree)

21 Insert 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)

22 Delete 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.

23 Delete Three cases: (1) the node is a leaf  Delete it immediately (2) the node has one child  Adjust a pointer from the parent to bypass that node

24 Delete (3) the node has 2 children  replace the key of that node with the minimum element at the right subtree  delete the 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)

25 12/26/03AVL Trees - Lecture 825 Binary search tree – best time  All BST operations are O(d), where d is tree depth  minimum d is for a binary tree with N nodes  What is the best case tree?  What is the worst case tree?  So, best case running time of BST operations is O(log N)

26 12/26/03AVL Trees - Lecture 826 Binary Search Tree - Worst Time  Worst case running time is O(N)  What happens when you insert elements in ascending order?  Insert: 2, 4, 6, 8, 10, 12 into an empty BST  Problem: Lack of “ balance ” :  compare depths of left and right subtree  Unbalanced degenerate tree

27 12/26/03AVL Trees - Lecture 827 Balanced and unbalanced BST Is this “ balanced ” ?

28 12/26/03AVL Trees - Lecture 828 Approaches to balancing trees  Don't balance  May end up with some nodes very deep  Strict balance  The tree must always be balanced perfectly  Pretty good balance  Only allow a little out of balance  Adjust on access  Self-adjusting

29 12/26/03AVL Trees - Lecture 829 Balancing binary search trees  Many algorithms exist for keeping binary search trees balanced  Adelson-Velskii and Landis (AVL) trees (height- balanced trees)  Splay trees and other self-adjusting trees  B-trees and other multiway search trees

30 12/26/03AVL Trees - Lecture 830 Perfect balance  Want a complete tree after every operation  tree is full except possibly in the lower right  This is expensive  For example, insert 2 in the tree on the left and then rebuild as a complete tree Insert 2 & complete tree

31 12/26/03AVL Trees - Lecture 831 AVL - good but not perfect balance  AVL trees are height-balanced binary search trees  Balance factor of a node  height(left subtree) - height(right subtree)  An AVL tree has balance factor calculated at every node  For every node, heights of left and right subtree can differ by no more than 1  Store current heights in each node

32 12/26/03AVL Trees - Lecture 832 Height of an AVL tree  N(h) = minimum number of nodes in an AVL tree of height h.  Basis  N(0) = 1, N(1) = 2  Induction  N(h) = N(h-1) + N(h-2) + 1  Solution (recall Fibonacci analysis)  N(h) >  h (   1.62) h-1 h-2 h

33 12/26/03AVL Trees - Lecture 833 Height of an AVL Tree  N(h) >  h (   1.62)  Suppose we have n nodes in an AVL tree of height h.  n > N(h) (because N(h) was the minimum)  n >  h hence log  n > h (relatively well balanced tree!!)  h < 1.44 log 2 n (i.e., Find takes O(logn))

34 12/26/03AVL Trees - Lecture 834 Node Heights height of node = h balance factor = h left -h right empty height = height=2 BF=1-0= Tree A (AVL)Tree B (AVL)

35 12/26/03AVL Trees - Lecture 835 Node heights after insert height of node = h balance factor = h left -h right empty height = balance factor 1-(-1) = 2 Tree A (AVL)Tree B (not AVL)

36 12/26/03AVL Trees - Lecture 836 Insert and rotation in AVL trees  Insert operation may cause balance factor to become 2 or – 2 for some node  only nodes on the path from insertion point to root node have possibly changed in height  So after the Insert, go back up to the root node by node, updating heights  If a new balance factor (the difference h left -h right ) is 2 or –2, adjust tree by rotation around the node

37 12/26/03AVL Trees - Lecture 837 Single Rotation in an AVL Tree

38 12/26/03AVL Trees - Lecture 838 Let the node that needs rebalancing be . There are 4 cases: Outside Cases (require single rotation) : 1. Insertion into left subtree of left child of . 2. Insertion into right subtree of right child of . Inside Cases (require double rotation) : 3. Insertion into right subtree of left child of . 4. Insertion into left subtree of right child of . The rebalancing is performed through four separate rotation algorithms. Insertions in AVL trees

39 12/26/03AVL Trees - Lecture 839 j k XY Z Consider a valid AVL subtree AVL insertion: outside case h h h

40 12/26/03AVL Trees - Lecture 840 j k X Y Z Inserting into X destroys the AVL property at node j AVL Insertion: Outside Case h h+1h

41 12/26/03AVL Trees - Lecture 841 j k X Y Z Do a “ right rotation ” AVL Insertion: Outside Case h h+1h

42 12/26/03AVL Trees - Lecture 842 j k X Y Z Do a “ right rotation ” Single right rotation h h+1h

43 12/26/03AVL Trees - Lecture 843 j k X Y Z “ Right rotation ” done! ( “ Left rotation ” is mirror symmetric) Outside Case Completed AVL property has been restored! h h+1 h

44 12/26/03AVL Trees - Lecture 844 j k XY Z AVL Insertion: Inside Case Consider a valid AVL subtree h h h

45 12/26/03AVL Trees - Lecture 845 Inserting into Y destroys the AVL property at node j j k X Y Z AVL Insertion: Inside Case Does “ right rotation ” restore balance? h h+1h

46 12/26/03AVL Trees - Lecture 846 j k X Y Z “ Right rotation ” does not restore balance… now k is out of balance AVL Insertion: Inside Case h h+1 h

47 12/26/03AVL Trees - Lecture 847 Consider the structure of subtree Y… j k X Y Z AVL Insertion: Inside Case h h+1h

48 12/26/03AVL Trees - Lecture 848 j k X V Z W i Y = node i and subtrees V and W AVL Insertion: Inside Case h h+1h h or h-1

49 12/26/03AVL Trees - Lecture 849 j k X V Z W i AVL Insertion: Inside Case We will do a left-right “ double rotation ”...

50 12/26/03AVL Trees - Lecture 850 j k X V Z W i Double rotation : first rotation left rotation complete

51 12/26/03AVL Trees - Lecture 851 j k X V Z W i Double rotation : second rotation Now do a right rotation

52 12/26/03AVL Trees - Lecture 852 j k X V Z W i Double rotation : second rotation right rotation complete Balance has been restored h h h or h-1

53 12/26/03AVL Trees - Lecture 853 Implementation balance (1,0,-1) key right left No need to keep the height; just the difference in height, i.e. the balance factor; this has to be modified on the path of insertion even if you don ’ t perform rotations Once you have performed a rotation (single or double) you won ’ t need to go back up the tree

54 12/26/03AVL Trees - Lecture 854 Single Rotation RotateFromRight(n : reference node pointer) { p : node pointer; p := n.right; n.right := p.left; p.left := n; n := p } X YZ n You also need to modify the heights or balance factors of n and p Insert

55 12/26/03AVL Trees - Lecture 855 Double Rotation  Implement Double Rotation in two lines. DoubleRotateFromRight(n : reference node pointer) { ???? } X n VW Z

56 12/26/03AVL Trees - Lecture 856 Insertion in AVL Trees  Insert at the leaf (as for all BST)  only nodes on the path from insertion point to root node have possibly changed in height  So after the Insert, go back up to the root node by node, updating heights  If a new balance factor (the difference h left -h right ) is 2 or –2, adjust tree by rotation around the node

57 12/26/03AVL Trees - Lecture 857 Insert in BST Insert(T : reference tree pointer, x : element) : integer { if T = null then T := new tree; T.data := x; return 1;//the links to //children are null case T.data = x : return 0; //Duplicate do nothing T.data > x : return Insert(T.left, x); T.data < x : return Insert(T.right, x); endcase }

58 12/26/03AVL Trees - Lecture 858 Insert in AVL trees Insert(T : reference tree pointer, x : element) : { if T = null then {T := new tree; T.data := x; height := 0; return;} case T.data = x : return ; //Duplicate do nothing T.data > x : Insert(T.left, x); if ((height(T.left)- height(T.right)) = 2){ if (T.left.data > x ) then //outside case T = RotatefromLeft (T); else //inside case T = DoubleRotatefromLeft (T);} T.data < x : Insert(T.right, x); code similar to the left case Endcase T.height := max(height(T.left),height(T.right)) +1; return; }

59 12/26/03AVL Trees - Lecture 859 Example of Insertions in an AVL Tree Insert 5, 40

60 12/26/03AVL Trees - Lecture 860 Example of Insertions in an AVL Tree Now Insert 45

61 12/26/03AVL Trees - Lecture 861 Single rotation (outside case) Imbalance Now Insert 34

62 12/26/03AVL Trees - Lecture 862 Double rotation (inside case) Imbalance Insertion of

63 12/26/03AVL Trees - Lecture 863 AVL Tree Deletion  Similar but more complex than insertion  Rotations and double rotations needed to rebalance  Imbalance may propagate upward so that many rotations may be needed.

64 12/26/03AVL Trees - Lecture 864 Arguments for AVL trees: 1.Search is O(log N) since AVL trees are always balanced. 2.Insertion and deletions are also O(logn) 3.The height balancing adds no more than a constant factor to the speed of insertion. Arguments against using AVL trees: 1.Difficult to program & debug; more space for balance factor. 2.Asymptotically faster but rebalancing costs time. 3.Most large searches are done in database systems on disk and use other structures (e.g. B-trees). 4.May be OK to have O(N) for a single operation if total run time for many consecutive operations is fast (e.g. Splay trees). Pros and Cons of AVL Trees

65 12/26/03AVL Trees - Lecture 865 Double Rotation Solution DoubleRotateFromRight(n : reference node pointer) { RotateFromLeft(n.right); RotateFromRight(n); } X n VW Z

66 Outline  Balanced Search Trees 2-3 Trees Trees Red-Black Trees

67 Why care about advanced implementations ? Same entries, different insertion sequence:  Not good! Would like to keep tree balanced.

68 2-3 Trees  each internal node has either 2 or 3 children  all leaves are at the same level Features

69 2-3 Trees with Ordered Nodes 2-node3-node leaf node can be either a 2-node or a 3-node

70 Example of 2-3 Tree

71 Traversing a 2-3 Tree inorder(in ttTree: TwoThreeTree) if(ttTree’s root node r is a leaf) visit the data item(s) else if(r has two data items) { inorder(left subtree of ttTree’s root) visit the first data item inorder(middle subtree of ttTree’s root) visit the second data item inorder(right subtree of ttTree’s root) } else { inorder(left subtree of ttTree’s root) visit the data item inorder(right subtree of ttTree’s root) }

72 Searching a 2-3 tree retrieveItem(in ttTree: TwoThreeTree, in searchKey:KeyType, out treeItem:TreeItemType):boolean if(searchKey is in ttTree’s root node r) { treeItem = the data portion of r return true } else if(r is a leaf) return false else { return retrieveItem(appropriate subtree, searchKey, treeItem) }

73 What did we gain? What is the time efficiency of searching for an item?

74 Gain: Ease of Keeping the Tree Balanced Binary Search Tree 2-3 Tree both trees after inserting items 39, 38,... 32

75 Inserting Items Insert 39

76 Inserting Items Insert 38 insert in leaf divide leaf and move middle value up to parent result

77 Inserting Items Insert 37

78 Inserting Items Insert 36 insert in leaf divide leaf and move middle value up to parent overcrowded node

79 Inserting Items... still inserting 36 divide overcrowded node, move middle value up to parent, attach children to smallest and largest result

80 Inserting Items After Insertion of 35, 34, 33

81 Inserting so far

82

83 Inserting Items How do we insert 32?

84 Inserting Items  creating a new root if necessary  tree grows at the root

85 Inserting Items Final Result

86 70 Deleting Items Delete 70 80

87 Deleting Items Deleting 70: swap 70 with inorder successor (80)

88 Deleting Items Deleting 70:... get rid of 70

89 Deleting Items Result

90 Deleting Items Delete 100

91 Deleting Items Deleting 100

92 Deleting Items Result

93 Deleting Items Delete 80

94 Deleting Items Deleting 80...

95 Deleting Items Deleting 80...

96 Deleting Items Deleting 80...

97 Deleting Items Final Result comparison with binary search tree

98 Deletion Algorithm I 1.Locate node n, which contains item I 2.If node n is not a leaf  swap I with inorder successor  deletion always begins at a leaf 3.If leaf node n contains another item, just delete item I else try to redistribute nodes from siblings (see next slide) if not possible, merge node (see next slide) Deleting item I :

99 Deletion Algorithm II A sibling has 2 items:  redistribute item between siblings and parent No sibling has 2 items:  merge node  move item from parent to sibling Redistribution Merging

100 Deletion Algorithm III Internal node n has no item left  redistribute Redistribution not possible:  merge node  move item from parent to sibling  adopt child of n If n 's parent ends up without item, apply process recursively Redistribution Merging

101 Deletion Algorithm IV If merging process reaches the root and root is without item  delete root

102 Operations of 2-3 Trees all operations have time complexity of log n

103 2-3-4 Trees similar to 2-3 trees 4-nodes can have 3 items and 4 children 4-node

104 2-3-4 Tree example

105 2-3-4 Tree: Insertion Insertion procedure: similar to insertion in 2-3 trees items are inserted at the leafs since a 4-node cannot take another item, 4-nodes are split up during insertion process Strategy on the way from the root down to the leaf: split up all 4-nodes "on the way"  insertion can be done in one pass (remember: in 2-3 trees, a reverse pass might be necessary)

106 2-3-4 Tree: Insertion Inserting 60, 30, 10, 20, 50, 40, 70, 80, 15, 90, 100

107 2-3-4 Tree: Insertion Inserting 60, 30, 10, , 40...

108 2-3-4 Tree: Insertion Inserting 50, ,...

109 2-3-4 Tree: Insertion Inserting , 15...

110 2-3-4 Tree: Insertion Inserting 80,

111 2-3-4 Tree: Insertion Inserting

112 2-3-4 Tree: Insertion Inserting

113 2-3-4 Tree: Insertion Procedure Splitting 4-nodes during Insertion

114 2-3-4 Tree: Insertion Procedure Splitting a 4-node whose parent is a 2-node during insertion

115 2-3-4 Tree: Insertion Procedure Splitting a 4-node whose parent is a 3-node during insertion

116 2-3-4 Tree: Deletion Deletion procedure: similar to deletion in 2-3 trees items are deleted at the leafs  swap item of internal node with inorder successor note: a 2-node leaf creates a problem Strategy (different strategies possible) on the way from the root down to the leaf: turn 2-nodes (except root) into 3-nodes  deletion can be done in one pass (remember: in 2-3 trees, a reverse pass might be necessary)

117 2-3-4 Tree: Deletion Turning a 2-node into a 3-node... Case 1: an adjacent sibling has 2 or 3 items "steal" item from sibling by rotating items and moving subtree "rotation"

118 2-3-4 Tree: Deletion Turning a 2-node into a 3-node... Case 2: each adjacent sibling has only one item  "steal" item from parent and merge node with sibling (note: parent has at least two items, unless it is the root) merging

119 2-3-4 Tree: Deletion Practice Delete 32, 35, 40, 38, 39, 37, 60

120 Red-Black Tree binary-search-tree representation of tree 3- and 4-nodes are represented by equivalent binary trees red and black child pointers are used to distinguish between original 2-nodes and 2-nodes that represent 3- and 4-nodes

121 Red-Black Representation of 4-node

122 Red-Black Representation of 3-node

123 Red-Black Tree Example

124

125 Red-Black Tree Operations Traversals  same as in binary search trees Insertion and Deletion  analog to tree  need to split 4-nodes  need to merge 2-nodes

126 Splitting a 4-node that is a root

127 Splitting a 4-node whose parent is a 2-node

128 Splitting a 4-node whose parent is a 3-node

129

130

131 Motivation for B-Trees  So far we have assumed that we can store an entire data structure in main memory  What if we have so much data that it won ’ t fit?  We will have to use disk storage but when this happens our time complexity fails  The problem is that Big-Oh analysis assumes that all operations take roughly equal time  This is not the case when disk access is involved

132 Motivation (cont.)  Assume that a disk spins at 3600 RPM  In 1 minute it makes 3600 revolutions, hence one revolution occurs in 1/60 of a second, or 16.7ms  On average what we want is half way round this disk – it will take 8ms  This sounds good until you realize that we get 120 disk accesses a second – the same time as 25 million instructions  In other words, one disk access takes about the same time as 200,000 instructions  It is worth executing lots of instructions to avoid a disk access

133 Motivation (cont.)  Assume that we use an Binary tree to store all the details of people in Canada (about 32 million records)  We still end up with a very deep tree with lots of different disk accesses; log 2 20,000,000 is about 25, so this takes about 0.21 seconds (if there is only one user of the program)  We know we can ’ t improve on the log n for a binary tree  But, the solution is to use more branches and thus less height!  As branching increases, depth decreases

134 Definition of a B-tree  A B-tree of order m is an m -way tree (i.e., a tree where each node may have up to m children) in which: 1.the number of keys in each non-leaf node is one less than the number of its children and these keys partition the keys in the children in the fashion of a search tree 2.all leaves are on the same level 3.all non-leaf nodes except the root have at least  m / 2  children 4.the root is either a leaf node, or it has from two to m children 5.a leaf node contains no more than m – 1 keys  The number m should always be odd

135 An example B-Tree A B-tree of order 5 containing 26 items Note that all the leaves are at the same level

136  Suppose we start with an empty B-tree and keys arrive in the following order:  We want to construct a B-tree of order 5  The first four items go into the root:  To put the fifth item in the root would violate condition 5  Therefore, when 25 arrives, pick the middle key to make a new root Constructing a B-tree 12812

137 Add 25 to the tree Exceeds Order. Promote middle and split.

138 Constructing a B-tree (contd.) 6, 14, 28 get added to the leaf nodes:

139 Constructing a B-tree (contd.) Adding 17 to the right leaf node would over-fill it, so we take the middle key, promote it (to the root) and split the leaf

140 Constructing a B-tree (contd.) 7, 52, 16, 48 get added to the leaf nodes

141 Constructing a B-tree (contd.) Adding 68 causes us to split the right most leaf, promoting 48 to the root

142 Constructing a B-tree (contd.) Adding 3 causes us to split the left most leaf

143 Constructing a B-tree (contd.) Add 26, 29, 53, 55 then go into the leaves

144 Constructing a B-tree (contd.) Add 45 increases the trees level Exceeds Order. Promote middle and split.

145 Inserting into a B-Tree  Attempt to insert the new key into a leaf  If this would result in that leaf becoming too big, split the leaf into two, promoting the middle key to the leaf ’ s parent  If this would result in the parent becoming too big, split the parent into two, promoting the middle key  This strategy might have to be repeated all the way to the top  If necessary, the root is split in two and the middle key is promoted to a new root, making the tree one level higher

146 Exercise in Inserting a B-Tree  Insert the following keys to a 5-way B-tree:  3, 7, 9, 23, 45, 1, 5, 14, 25, 24, 13, 11, 8, 19, 4, 31, 35, 56

147 Answer to Exercise Java Applet Source

148 Removal from a B-tree  During insertion, the key always goes into a leaf. For deletion we wish to remove from a leaf. There are three possible ways we can do this:  1 - If the key is already in a leaf node, and removing it doesn’t cause that leaf node to have too few keys, then simply remove the key to be deleted.  2 - If the key is not in a leaf then it is guaranteed (by the nature of a B-tree) that its predecessor or successor will be in a leaf -- in this case can we delete the key and promote the predecessor or successor key to the non-leaf deleted key’s position.

149 Removal from a B-tree (2)  If (1) or (2) lead to a leaf node containing less than the minimum number of keys then we have to look at the siblings immediately adjacent to the leaf in question:  3: if one of them has more than the min’ number of keys then we can promote one of its keys to the parent and take the parent key into our lacking leaf  4: if neither of them has more than the min’ number of keys then the lacking leaf and one of its neighbours can be combined with their shared parent (the opposite of promoting a key) and the new leaf will have the correct number of keys; if this step leave the parent with too few keys then we repeat the process up to the root itself, if required

150 Type #1: Simple leaf deletion Delete 2: Since there are enough keys in the node, just delete it Assuming a 5-way B-Tree, as before... Note when printed: this slide is animated

151 Type #2: Simple non-leaf deletion Delete 52 Borrow the predecessor or (in this case) successor 56 Note when printed: this slide is animated

152 Type #4: Too few keys in node and its siblings Delete 72 Too few keys! Join back together Note when printed: this slide is animated

153 Type #4: Too few keys in node and its siblings Note when printed: this slide is animated

154 Type #3: Enough siblings Delete 22 Demote root key and promote leaf key Note when printed: this slide is animated

155 Type #3: Enough siblings Note when printed: this slide is animated

156 Exercise in Removal from a B-Tree  Given 5-way B-tree created by these data (last exercise):  3, 7, 9, 23, 45, 1, 5, 14, 25, 24, 13, 11, 8, 19, 4, 31, 35, 56  Add these further keys: 2, 6,12  Delete these keys: 4, 5, 7, 3, 14

157 Answer to Exercise Java Applet Source

158 Analysis of B-Trees  The maximum number of items in a B-tree of order m and height h : root m – 1 level 1 m ( m – 1) level 2 m 2 ( m – 1)... level h m h ( m – 1) m h +1 – 1  So, the total number of items is (1 + m + m 2 + m 3 + … + m h )( m – 1) = [( m h +1 – 1)/ ( m – 1)] ( m – 1) = m h +1 – 1  When m = 5 and h = 2 this gives 5 3 – 1 = 124

159 Reasons for using B-Trees  When searching tables held on disc, the cost of each disc transfer is high but doesn't depend much on the amount of data transferred, especially if consecutive items are transferred  If we use a B-tree of order 101, say, we can transfer each node in one disc read operation  A B-tree of order 101 and height 3 can hold – 1 items (approximately 100 million) and any item can be accessed with 3 disc reads (assuming we hold the root in memory)  If we take m = 3, we get a 2-3 tree, in which non-leaf nodes have two or three children (i.e., one or two keys)  B-Trees are always balanced (since the leaves are all at the same level), so 2-3 trees make a good type of balanced tree


Download ppt "Data Structures and Algorithms Course’s slides: Hierarchical data structures www.mif.vu.lt/~algis."

Similar presentations


Ads by Google