CS 2412 Data Structures. Chapter 8 Multiway Trees

Transcription

1 CS 2412 Data Structures Chapter 8 Multiway Trees

2 This chapter studies multiway trees. These trees can be used for external search. When searched data is big, it is not suitable to load all the data to memory. Search in high-speed memory is much faster than search in external devices (hard discs, CD etc.) The idea of external search: each time read in a block of information to the memory and decide what is the next block we should search on. Data Structure 2015 R. Wei 2

3 Definition An m-way tree has the following properties. Each node has 0 to m subtrees. A node with k < m subtrees contains k subtrees and k 1 data entries. The keys of the data entries are ordered: key 1 key 2 key k 1. The key values in the first subtree (0th subtree) are all less than key 1 ; the key values in the ith subtrees are all greater than or equal to key i but less than key i+1. All subtrees are themselves multiway trees. A 2-way tree is a BST. Data Structure 2015 R. Wei 3

4 Data Structure 2015 R. Wei 4

5 Data Structure 2015 R. Wei 5

6 We also want the multisay tree to be balance. Definition A B-tree is an m-way tree with the following additional properties: The root is either a leaf or it has 2 to m subtrees. All internal nodes have at least m/2 nonnull subtrees. All leaf nodes are at the same level. A leaf node has at least m/2 1 entries. Data Structure 2015 R. Wei 6

7 Data Structure 2015 R. Wei 7

8 Data structure of B-tree. The structure of m-way tree: an entry of a node contains data and a pointer to its right subtree. A node contains the first pointer to the subtree with entries less than the key of the first entry, a count of the number of entries currently in the node, and an array of entries. The array can be of size m. Main operations for B-trees are: insert, delete, traverse and search. Data Structure 2015 R. Wei 8

9 Data Structure 2015 R. Wei 9

10 B-tree insertion: B-tree insertion takes place at a leaf node. Locate the leaf node where the data can be inserted. If the node is not full (has less than m 1 entries), insert the data to this node. If the node is full (called overflow condition), split the node into two node. A B-tree grows from the bottom up. Data Structure 2015 R. Wei 10

11 Example Insert 11, 21, 14, 78, 97 to a B-tree of order 5: Data Structure 2015 R. Wei 11

12 The algorithm of B-tree insert: If the B-tree is empty, then create the root and insert the first entry. If the B-tree is not empty, call the insert node algorithm which finds the location, insert it and do necessary update (if overflow, then split and install the median entry to the parent etc.). If the root needs to split, then create a new root. Data Structure 2015 R. Wei 12

13 Algorithm BTreeInsert( tree, data) if (tree empty) create new node set left subtree of node to null move data to first entry in new node set subtree of first entry to null set tree root to address of new node set number of entries to 1 else insertnode(tree, data, upentry) end if if (tree higher) create new node move upentry to first entry in new node set left subtree of the new node to tree set tree root to new node set number of entries to 1 end if Data Structure 2015 R. Wei 13

14 Data Structure 2015 R. Wei 14

15 Data Structure 2015 R. Wei 15

16 Algorithm searchnode(nodeptr, target) if (target < key in first entry) return 0 end if set walker to number of entries -1 loop (targer < entry key[walker]) decrement walker end loop return walker This function returns the index to entry with key target, or 0 if the key < first entry in node. Data Structure 2015 R. Wei 16

17 Algorithm splitnode (node, entryndx, newentrylow, upentry) create new node move high entries to new node if (entryndx < minimum entries) inset upentry in new node end if move median data to upentry make new node first Ptr the right subtree of median data make new node the right subtree of upentry Data Structure 2015 R. Wei 17

18 Data Structure 2015 R. Wei 18

19 Data Structure 2015 R. Wei 19

20 Data Structure 2015 R. Wei 20

21 Data Structure 2015 R. Wei 21

22 B-tree deletion: B-tree deletion is a little more complicated than insertion. Search for the data to be deleted. If can t find, then print an error message and quit. If the data is found, then delete the data. Two cases need to consider: the data at leaf node or non-leaf node. If an underflow (a leaf node has less than m/2 1 entries or an internal node has less than m/2 nonull subtrees) occurred after the data deletion, then adjustment must be done. Data Structure 2015 R. Wei 22

23 The following algorithm delete an entry. Some situations are considered: empty tree, the root is empty after deletion. Leave the details about how to treat underflow to algorithm delete. Algorithm BTreeDelete (tree, dltkey) if (tree empty) return false end if delete (tree, dltkey, success) if (success) if(tree number of entries zero) set tree to left subtree end if end if return success Data Structure 2015 R. Wei 23

24 Data Structure 2015 R. Wei 24

25 6 end if 6 end if 7 return underflow end delete Data Structure 2015 R. Wei 25

26 The following algorithm deletes the entry from a leaf node and returns the value of underflow. Algorithm deleteentry (node, entryndx) delete entry at entryndx from node shift entries after delete to left if (number of entries less minimum, entries) return true else retrun false end if Data Structure 2015 R. Wei 26

27 When deleting an entry in an internal node, we must find substitute data. We use the immediate predecessor, which is the largest node on the left subtree of the entry to be deleted. In the subtree, the largest node is the rightmost subtree. Algorithm deletemid (node, entryndx, subtree) if (no rightmost subtree) //predecessor in a leaf node move predecessor s data to deleted entry set underflow if node entries less minimum else set underflow to deletemid(node, entryndx, right subtree) if (underflow) set underflow to reflow(root, entryndx) end if end if return underflow Data Structure 2015 R. Wei 27

28 When a node is underflow, we need to do some adjustment which we call reflow. Suppose one of the subtree contains unerflow node, two situations need to consider: If the other subtree has more entries than the minimum number, than we just move some entry to the underflow node, which we call it balance. If the other subtree only has minimum number of entries, then we need to combine two node to one node together with the root entry. This is called combine. Data Structure 2015 R. Wei 28

29 Algorithm reflow (root, entryndx) if (righttree entries greater minimum entries) borrowright (root, entryndx, lefttree, righttree) set underflow to false else if (lefttree entries greater minimum entries) borrowleft (root, entryndx, lefttree, righttree) set underflow to false else combine (root, entryndx, lefttree, righttree) if (root numentries less minimum entries) set underflow to true else set underflow to false end if end if return underflow Data Structure 2015 R. Wei 29

30 Data Structure 2015 R. Wei 30

31 Algorithm borrowleft(root, entryndx, left, right) shift all elements one to the right move root data to first entry in right move right first pointer to right subtree of first entry move left last right pointer to right first pointer move left last entry data to root at entryndx In above algorithm, when an entry is moved the according pointers are also adjusted. (To see that, consider the underflow node is not a leaf node). The algorithm of borrowright is similar. Data Structure 2015 R. Wei 31

32 Data Structure 2015 R. Wei 32

33 Algorithm combine (root, entryndx, left, right) move parent entry to first open entry in left subtree move right subtree first subtree to moved parent left subtree move entries from right subtree to end of left subtree shift root data to left Data Structure 2015 R. Wei 33

34 Example Data Structure 2015 R. Wei 34

35 Data Structure 2015 R. Wei 35

36 Similar to BST, the traversal of a B-tree uses inorder. The difference is that except of leaf nodes, the data in a node is not processed at the same time. Data Structure 2015 R. Wei 36

37 Algorithm BTreeTraversal (root) set scancount to 0 set nextsubtree to root left subtree loop (scancount <= number of entries) if (nextsubtree not null) BTreeTraversal (nextsubtree) end if if (ScanCount < number of entries) process (entry[scancount]) set nextsubtree to current entry right subtree end if increment scanount end loop Data Structure 2015 R. Wei 37

38 The B-tree search algorithm follow the similar idea of search a binary tree. But we need find the node and then find the entry in that node. In this case, we need to return both the node and the location of the entry in that node. Recursive method are used for finding the node. At the node found, compare from the last entry to the first entry. Data Structure 2015 R. Wei 38

39 Data Structure 2015 R. Wei 39

40 Data Structure 2015 R. Wei 40

41 typedef struct void* dataptr; struct node* rightptr; } ENTRY; typedef struct node struct node* firstptr; int numentries; ENTRY entries[order - 1]; } NODE; typedef struct int count; NODE* root; int (*compare) (void* argu1, void* argu2); } BTREE; Data Structure 2015 R. Wei 41

42 void* BTree_Search (BTREE* tree, void* targetptr) if (tree->root) return _search (tree, targetptr, tree->root); else return NULL; } // BTree_Search Data Structure 2015 R. Wei 42

43 void* _search (BTREE* tree, void* targetptr, NODE* root) int entryno; if (!root) return NULL; if (tree->compare(targetptr, root->entries[0].dataptr) < 0) return _search (tree, targetptr, root->firstptr); entryno = root->numentries - 1; while (tree->compare(targetptr, root->entries[entryno].dataptr) < 0) entryno--; if (tree->compare(targetptr, root->entries[entryno].dataptr) == 0) return (root->entries[entryno].dataptr); return (_search (tree, targetptr, root->entries[entryno].rightptr)); } // _search Data Structure 2015 R. Wei 43

44 void BTree_Traverse (BTREE* tree, void (*process) (void* dataptr)) // Statements if (tree->root) _traverse (tree->root, process); return; } // end BTree_Traverse Data Structure 2015 R. Wei 44

45 void _traverse (NODE* root, void (*process) (void* dataptr)) int scancount; NODE* ptr; scancount = 0; ptr = root->firstptr; while (scancount <= root->numentries) if (ptr) _traverse (ptr, process); // Subtree processed -- get next entry if (scancount < root->numentries) process (root->entries[scancount].dataptr); ptr = root->entries[scancount].rightptr; } // if scancount scancount++; } // if return; } // _traverse Data Structure 2015 R. Wei 45

46 void BTree_Insert (BTREE* tree, void* datainptr) bool taller; NODE* newptr; ENTRY upentry; if (tree->root == NULL) // Empty Tree. Insert first node if (newptr = (NODE*)malloc(sizeof (NODE))) newptr->firstptr = NULL; newptr->numentries = 1; newptr->entries[0].dataptr = datainptr; newptr->entries[0].rightptr = NULL; tree->root = newptr; (tree->count)++; for (int i = 1; i < ORDER - 1; i++) Data Structure 2015 R. Wei 46

47 newptr->entries[i].dataptr = NULL; newptr->entries[i].rightptr = NULL; } // for * return; } // if malloc else printf("overflow error 100 in BTree_Insert\a\n"), exit (100); taller = _insert (tree, tree->root, datainptr, &upentry); if (taller) // Tree has grown. Create new root newptr = (NODE*)malloc(sizeof(NODE)); if (newptr) Data Structure 2015 R. Wei 47

48 newptr->entries[0] = upentry; newptr->firstptr = tree->root; newptr->numentries = 1; tree->root = newptr; } // if newptr else printf("overflow error 101\a\n"), exit (100); } // if taller (tree->count)++; return; } // BTree_Insert Data Structure 2015 R. Wei 48

49 bool _insert (BTREE* tree, NODE* root, void* datainptr, ENTRY* upentry) int compresult; int entryndx; bool taller; NODE* subtreeptr; if (!root) (*upentry).dataptr = datainptr; (*upentry).rightptr = NULL; return true; // tree taller } // if NULL tree entryndx = _searchnode (tree, root, datainptr); compresult = tree->compare(datainptr, root->entries[entryndx].dataptr); Data Structure 2015 R. Wei 49

50 if (entryndx <= 0 && compresult < 0) // in node s first subtree subtreeptr = root->firstptr; else // in entry s right subtree subtreeptr = root->entries[entryndx].rightptr; taller = _insert (tree, subtreeptr, datainptr, upentry); if (taller) if (root->numentries >= ORDER - 1) // Need to create new node _splitnode (root, entryndx, compresult, upentry); taller = true; Data Structure 2015 R. Wei 50

51 } // node full else if (compresult >= 0) // New data >= current entry -- insert after _insertentry(root, entryndx + 1, *upentry); else // Insert before current entry _insertentry(root, entryndx, *upentry); (root->numentries)++; taller = false; } // else } // if taller return taller; } // _insert Data Structure 2015 R. Wei 51

52 void _splitnode (NODE* node, int entryndx, int compresult, ENTRY* upentry) int fromndx; int tondx; NODE* rightptr; rightptr = (NODE*)malloc(sizeof (NODE)); if (!rightptr) printf("overflow Error 101 in _splitnode\a\n"), exit (100); if (entryndx < MIN_ENTRIES) fromndx = MIN_ENTRIES; else fromndx = MIN_ENTRIES + 1; tondx = 0; rightptr->numentries = node->numentries - fromndx; Data Structure 2015 R. Wei 52

53 while (fromndx < node->numentries) rightptr->entries[tondx++] = node->entries[fromndx++]; node->numentries = node->numentries - rightptr->numentries; if (entryndx < MIN_ENTRIES) if (compresult < 0) _insertentry (node, entryndx, *upentry); else _insertentry (node, entryndx + 1, *upentry); } // if else _insertentry (rightptr, entryndx - MIN_ENTRIES, Data Structure 2015 R. Wei 53

54 *upentry); (rightptr->numentries)++; (node->numentries)--; } // else upentry->dataptr = node->entries[min_entries].dataptr; upentry->rightptr = rightptr; rightptr->firstptr = node->entries[min_entries].rightptr; return; } // _splitnode Data Structure 2015 R. Wei 54

55 bool BTree_Delete (BTREE* tree, void* dltkey) bool success; NODE* dltptr; if (!tree->root) return false; _delete (tree, tree->root, dltkey, &success); if (success) (tree->count)--; if (tree->root->numentries == 0) dltptr = tree->root; Data Structure 2015 R. Wei 55

56 tree->root = tree->root->firstptr; free (dltptr); } // root empty } // success return success; } // BTree_Delete Data Structure 2015 R. Wei 56

57 bool _delete (BTREE* tree, NODE* root, void* dltkeyptr, bool* success) NODE* leftptr; NODE* subtreeptr; int entryndx; int underflow; if (!root) *success = false; return false; } // null tree entryndx = _searchnode (tree, root, dltkeyptr); if (tree->compare(dltkeyptr, root->entries[entryndx].dataptr) == 0) Data Structure 2015 R. Wei 57

58 *success = true; if (root->entries[entryndx].rightptr == NULL) underflow = _deleteentry (root, entryndx); else if (entryndx > 0) leftptr = root->entries[entryndx - 1].rightPtr; else leftptr = root->firstptr; underflow = _deletemid (root, entryndx, leftptr); if (underflow) underflow = _reflow (root, entryndx); } // else internal node } // else found entry Data Structure 2015 R. Wei 58

59 else if (tree->compare (dltkeyptr, root->entries[0].dataptr) < 0) subtreeptr = root->firstptr; else subtreeptr = root->entries[entryndx].rightptr; underflow = _delete (tree, subtreeptr, dltkeyptr, success); if (underflow) underflow = _reflow (root, entryndx); } // else not found * return underflow; } // _delete Data Structure 2015 R. Wei 59

60 bool _deletemid (NODE* root, int entryndx, NODE* subtreeptr) int dltndx; int rightndx; bool underflow; if (subtreeptr->firstptr == NULL) // leaf located. Exchange data & delete leaf dltndx = subtreeptr->numentries - 1; root->entries[entryndx].dataptr = subtreeptr->entries[dltndx].dataptr; --subtreeptr->numentries; underflow = subtreeptr->numentries < MIN_ENTRIES; } // if leaf Data Structure 2015 R. Wei 60

61 else // Not located. Traverse right for predecessor rightndx = subtreeptr->numentries - 1; underflow = _deletemid (root, entryndx, subtreeptr->entries[rightndx].rightptr); if (underflow) underflow = _reflow (subtreeptr, rightndx); } // else traverse right return underflow; } // _deletemid Data Structure 2015 R. Wei 61

62 bool _reflow (NODE* root, int entryndx) NODE* lefttreeptr; NODE* righttreeptr; bool underflow; if (entryndx == 0) lefttreeptr = root->firstptr; else lefttreeptr = root->entries[entryndx - 1].rightPtr; righttreeptr = root->entries[entryndx].rightptr; if (righttreeptr->numentries > MIN_ENTRIES) _borrowright (root, entryndx, lefttreeptr, righttreeptr); underflow = false; } // if borrow right else Data Structure 2015 R. Wei 62

63 // Can t borrow from right--try left if (lefttreeptr->numentries > MIN_ENTRIES) _borrowleft (root, entryndx, lefttreeptr, righttreeptr); underflow = false; } // if borrow left * else // Can t borrow. Must combine nodes. _combine (root, entryndx, lefttreeptr, righttreeptr); underflow = (root->numentries < MIN_ENTRIES); } // else combine } // else borrow right return underflow; } // _reflow Data Structure 2015 R. Wei 63

64 void _borrowright (NODE* root, int entryndx, NODE* lefttreeptr, NODE* righttreeptr) int tondx; int shifter; tondx = lefttreeptr->numentries; lefttreeptr->entries[tondx].dataptr = root->entries[entryndx].dataptr; lefttreeptr->entries[tondx].rightptr = righttreeptr->firstptr; ++lefttreeptr->numentries; root->entries[entryndx].dataptr = righttreeptr->entries[0].dataptr; Data Structure 2015 R. Wei 64

65 righttreeptr->firstptr = righttreeptr->entries[0].rightptr; shifter = 0; while (shifter < righttreeptr->numentries - 1) righttreeptr->entries[shifter] = righttreeptr->entries[shifter + 1]; ++shifter; } // while --righttreeptr->numentries; return; } // _borrowright Data Structure 2015 R. Wei 65

66 void _combine (NODE* root, int entryndx, NODE* lefttreeptr, NODE* righttreeptr) int tondx; int fromndx; int shifter; tondx = lefttreeptr->numentries; lefttreeptr->entries[tondx].dataptr = root->entries[entryndx].dataptr; lefttreeptr->entries[tondx].rightptr = righttreeptr->firstptr; ++lefttreeptr->numentries; --root->numentries; fromndx = 0; tondx++; while (fromndx < righttreeptr->numentries) Data Structure 2015 R. Wei 66

67 lefttreeptr->entries[tondx++] = righttreeptr->entries[fromndx++]; lefttreeptr->numentries += righttreeptr->numentries; free (righttreeptr); shifter = entryndx; while (shifter < root->numentries) root->entries[shifter] = root->entries[shifter + 1]; shifter++; } // while return; } // _combine Data Structure 2015 R. Wei 67

68 BTREE* BTree_Create (int BTREE* tree; (*compare) (void* argu1, void* argu2)) tree = (BTREE*) malloc (sizeof (BTREE)); if (tree) tree->root = NULL; tree->count = 0; tree->compare = compare; } // if return tree; } // BTree_Create Data Structure 2015 R. Wei 68

69 void BTree_Print (BTREE* tree) _print (tree->root, 0); return; } // BTree_PRINT void _print (NODE* root, int level) int scancount; NODE* ptr; void* voidptr; // Statements if (root) Data Structure 2015 R. Wei 69

70 scancount = root->numentries - 1; while (scancount >= 0) ptr = root->entries[scancount].rightptr; // Test for subtree if (ptr) _print (ptr, level + 1); // Subtree processed -- print current entry printf("(%02d)", level); for (int i = 1; i <= level; i++ ) printf ("." ); voidptr = root->entries[scancount].dataptr; printf("%4d", *((int*)voidptr)); Data Structure 2015 R. Wei 70

71 printf("\t--node: %p\n", root); scancount--; } // while // Process first pointer if (root->firstptr) _print (root->firstptr, level + 1); } // if root return; } // BTree_Print Data Structure 2015 R. Wei 71

72 Some special B-tree and variations: 2-3 Tree: a B-tree of order 3. (suitable for internal search) Tree: a B-tree of order 4. (suitable for internal search) B*tree: when a node overflows, instead of being split immediately, the data are tried to redistribute among the node s siblings. B+tree: Some data need to be processed both randomly and sequentially. In a B+tree, data are all stored in leaf nodes. The key in the internal node are just for searching. Each leaf node has one additional pointer pointed to the next leaf node. Data Structure 2015 R. Wei 72

73 Data Structure 2015 R. Wei 73

74 Data Structure 2015 R. Wei 74

75 Data Structure 2015 R. Wei 75

76 Tries A trie is a multiway tree which is used to search keys as a sequence of characters (letters or digits, for example). For example, if we want to search a key begin, then we first find b, then find be, then beg, and so on. In this way, the root has 26 children. And each node may have at most 26 children. So it is based on a 26-way tree. In English, there are no words beginning with bb, bc or, bf, bg,. So the according nodes can be pruned. Data Structure 2015 R. Wei 76

77 Data Structure 2015 R. Wei 77

78 To prune the tree, we cut all of the branches that are not needed. For example, if no key starts with letter X, then at level 0 the X pointer is null. Similarly, after the letter Q, the only valid letter is U. So all the pointers in the Q branch except U are set to null. As an example, we display a tries which only contains 5 letters A, B, C, E, and T. A node contains an array of 5. The node itself pointer to the letter if the letter exists. In this example, most pointers are null. Data Structure 2015 R. Wei 78

79 Data Structure 2015 R. Wei 79

80 Algorithm searchtrie (dictionary, word) set root to dictionary set ltrndx to 0 loop (root not null) if (root entry equals word) return true end if if (ltrndx > = word length) return false end if set chndx to word[ltrndx] set root to chndx subtree increment ltrndx end loop return false Data Structure 2015 R. Wei 80