Indexing. Introduction. Outline. Search Approach. Linear Index (Ch 10.1) Tree Index (Ch 10.3) 2-3 Tree (Ch 10.4) B-Tree (Ch 10.5) Introduction (Ch 10)

Transcription

1 Data Structure Chapter 10 Indexing Dr. Patrick Chan School of Computer Science and Engineering South China University of Technology Search Approach Sequential and List Method Sequential, Binary, Jump, Dictionary Search Discussed in previous chapter Direct Access by Key Value Hashing Discussed in previous chapter Tree indexing method 3 Outline Introduction (Ch 10) Linear Index (Ch 10.1) Tree Index (Ch 10.3) 2-3 Tree (Ch 10.4) B-Tree (Ch 10.5) B + -Tree (Ch ) 2 Introduction Entry-sequenced File Records are stored in the order that they were added to the file (unsorted list) Search is not efficient One solution is to sort the records by order of the search key Cannot handle multiple search keys, e.g. Find a student by name: sorted by name Find a student lived in : sorted by address Peter Mary Qingdao Susan Xian Jessica Tom Shenzhen

2 Introduction Indexing Peter A process of associating a key with the location of a corresponding data record Each key is associated with a pointer to a complete record The index file could be sorted or organized, thereby imposing a logical order on the records without physically rearranging them Might have several associated index files Peter Introduction Primary Key A unique identifier for records Not meaningful e.g. Student ID Inconvenient for search Secondary Key Alternate search key People may be more interested in it e.g. Score Often not unique for each record Frequently use 7 Introduction Indexing: Example Jessica Mary Peter Susan Tom Peter Mary Qingdao Susan Xian Jessica Tom Shenzhen Qingdao Shenzhen Xian 6 Linear Index Index file organized as a simple sequence of key/record pointer pairs with key values are in sorted order Linear indexing is good for searching variablelength records Linear Index Database Records 8 5

3 Linear Index Second-level index If the index is too large to fit in main memory, a second-level index might be used Second Level Index Linear Index: Disk Pages Database Records Linear Index Second-level index Drawbacks 1. The index update due to record inserting/deleting is expensive The entire contents of the array might be shifted by one position 2. Records with the same (secondary) key will waste memory space 11 Linear Index Second-level index Second-level index can be applied to secondary key search Second Level Index G Q X Linear Index: Disk Pages Qingdao Shenzhen Xia n Peter Mary Qingdao Susan Xian Jessica Tom Shenzhen Database Records 10 Linear Index: Second-level index Inverted Index Invert means searches work backwards from the secondary key to the primary key to the actual data record Solution of Drawback 2 A secondary key is associated with a primary key, which in turn locates the record Qingdao Shenzhen Xian Secondary Key Primary Key 12 9

4 13 15 Linear Index: Second-level index Inverted Index A drawback to this approach is that the array must be of fixed size Upper limit on the number of keys Memory Wasting Solution: Linked List? Qingdao Shenzhen Xian Linear Index: Second-level index Inverted Index Solution of Drawback 2 Second Level Index Gua ngzhou G S Qingdao Shenzhen Work well if the index is stored in main memory Xian Not so well when it is stored on disk the linked list for a given key might be scattered across several disk blocks Linear Index: Second-level index Inverted Index Another solution Combining the lists into one array based list Jones Smith Zukowski ZQ99 Secondary Key Jones Smith Zukowski AA10 AB12 AB39 FF37 Index AX AX35 ZX Primary Key AA10 AX ZX45 ZQ99 AB12 AB39 AX35 FF37 Next Tom Shenzhen Jessica Susan Xian Mary Qingdao Peter Database Records Linear Index: Second-level index Inverted Index Better solution: each secondary key has its own array list Example: A large database of employee records The primary key: the employee s ID number The secondary key: the employee s name The name index associates a name with one or more ID numbers The ID number index in turn associates an ID number with a unique pointer to the full record on disk Data records Secondary Key Primary Key AX AX35 ZX45 AA10 AB12 AB39 FF37 Jones Smith Zukowski ZQ99..

5 Linear index is poor for insertion/deletion Performance is poor when the database is large Tree index can efficiently support all desired operations: Insert/delete Multiple search keys (multiple indices) Key range search Two observations: Balanced Tree is preferable Decrease the node access A node and its parent on the same block is preferable Minimizes disk I/O Each path from root to leaf should cover few disk pages How about Binary Search Tree? Unbalance issue A BST node B is visited, all nodes along the path from the root to B are needed to access Each node on this path must be retrieved from disk Each disk access returns a block of information If a node is on the different block as its parent Requires read another block from disk 7 B BST is not a suitable structure Rebalance is expensive after insertion / deletion Example: 5 A node with value 1 is inserted Rebalance Unbalanced Balanced 18 20

6 : 2-3 Tree A node contains one or two keys Every internal node has either Two children (if it contains one key (left)) Three children (if it contains two keys) All leaves are at the same level in the tree, so the tree is always height balanced 2-3 Tree: Find Search K = Search K = 15 Search K = Tree template <class Elem> class TTNode { // 2-3 tree node structure public: Elem lkey; // The node's left key Elem rkey; // The node's right key TTNode* left; // Pointer to left child TTNode* center; // Pointer to middle child TTNode* right; // Pointer to right child ; TTNode() { center = left = right = NULL; lkey = rkey = EMPTY; ~TTNode() { bool isleaf() { return left == NULL; 12 left Null Null Null lkey rkey Null Null Null center rigth Null Null Null Tree: Find template <class Key, class Elem, class KEComp, class EEComp> bool TTTree<Key, Elem, KEComp, EEComp>:: findhelp(ttnode<elem>* subroot, const Key& K, Elem& e) const { if (subroot == NULL) // val not found return false; if (KEComp::eq(K, subroot->lkey)) { e = subroot->lkey; return true; if ((subroot->rkey!= EMPTY) && (KEComp::eq(K, subroot->rkey))) { e = subroot->rkey; return true; if (KEComp::lt( K, subroot->lkey)) // Search left return findhelp(subroot->left, K, e); else if (subroot->rkey == EMPTY) // Search center return findhelp(subroot->center, K, e); else if (KEComp::lt(K, subroot->rkey)) // Search center return findhelp(subroot->center, K, e); else return findhelp(subroot->right, K, e); // Right 12 Null Null Null NullNull Null Null Null Null 24

7 2-3 Tree: Find template <class Key, class Elem, class KEComp, class EEComp> bool TTTree<Key, Elem, KEComp, EEComp>:: findhelp(ttnode<elem>* subroot, const Key& K, Elem& e) const { if (subroot == NULL) // val not found return false; if (KEComp::eq(K, subroot->lkey)) { e = subroot->lkey; return true; if ((subroot->rkey!= EMPTY) && (KEComp::eq(K, subroot->rkey))) { e = subroot->rkey; return true; if (KEComp::lt( K, subroot->lkey)) // Search left return findhelp(subroot->left, K, e); else if (subroot->rkey == EMPTY) // Search center return findhelp(subroot->center, K, e); else if (KEComp::lt(K, subroot->rkey)) // Search center return findhelp(subroot->center, K, e); else return findhelp(subroot->right, K, e); // Right 12 Null Null Null 18 Null Null Null Null Null Null BC Bingo! L Bingo! R Search L Search C Search R 25 Insert 16 - Node Free (Right) Tree: Find Search K = Search K = BC Bingo! L Bingo! R Search L Search C Search R 18 BC Bingo! L Bingo! R Search L Search C Search R 12 BC Bingo! L Bingo! R Search L Search C Search R 15 BC Bingo! L Bingo! R Search L Search C Search R Insert 14 - Node Free (Left)

8 Insert 55 - Node Full (Right) - Parent Free (Right) Insert 51 - Node Full (Middle) - Parent Free (Right) Insert 49 - Node Full (Left) - Parent Free (Right) Insert 46 - Node Full (Middle) - Parent Free (Left)

9 Insert 11 (Node Full (Left), Parent is Full) Insert 22 (Node Full (Middle), Parent is Full) Insert 47 (Node Full (Right), Parent is Full) Small Exercise!!!! Insert Insert Insert Insert

10 Small Exercise!!!! Insert Insert Small Exercise!!!! Insert Small Exercise!!!! Insert Small Exercise!!!!

11 Insert Empty Leaf Search 1. Search if it is not a leaf node Reorganize 2. If it is a leaf node, add the new value ( may be necessary) 3. Handle the promoted value from its child if necessary 41 : retval: value being promoted retptr: pointer to newly created node template <class Key, class Elem, class KEComp, class EEComp> bool TTTree<Key, Elem, KEComp, EEComp>:: inserthelp(ttnode<elem>*& subroot, const Elem& e, Elem& retval, TTNode<Elem>*& retptr) { Elem myretv; TTNode<Elem>* myretp = NULL; if (subroot == NULL) { // Empty tree: make new node subroot = new TTNode<Elem>(); subroot->lkey = e; else if (subroot->isleaf()) // At leaf node: insert here if (subroot->rkey == EMPTY) { // Easy case: not full if (EEComp::gt(e, subroot->lkey)) subroot->rkey = e; else { subroot->rkey = subroot->lkey; subroot->lkey = e; else // if full splitnode(subroot, e, NULL, retval, retptr); else if (EEComp::lt(e, subroot->lkey)) // Find a correct position inserthelp(subroot->left, e, myretv, myretp); else if ((subroot->rkey == EMPTY) (EEComp::lt(e, subroot->rkey))) inserthelp(subroot->center, e, myretv, myretp); else inserthelp(subroot->right, e, myretv, myretp); Empty Leaf Search 43 bool insert(const Elem& e) { // Insert node with value val Elem retval; // Smallest value in newly created node TTNode<Elem>* retptr = NULL; // Newly created node bool issuccess = inserthelp(root, e, retval, retptr); if (retptr!= NULL) { // Root overflowed: make new root TTNode<Elem>* temp = new TTNode<Elem>; temp->lval = retval; temp->left = root; temp->center = retptr; root = temp; root->keycount = 1; return issuccess; 42 if (myretp!= NULL) // Child split: receive promoted value if (subroot->rkey!= EMPTY) // Full: split node splitnode(subroot, myretv, myretp, retval, retptr); else { // Not full: add to this node if (EEComp::lt(myretv, subroot->lkey)) { subroot->rkey = subroot->lkey; subroot->lkey = myretv; subroot->right = subroot->center; subroot->center = myretp; else { subroot->rkey = myretv; subroot->right = myretp; return true; Empty Leaf Search Reorganize 25 Insert

12 23 30 Empty Leaf Search Reorganize e = 15 inserthelp(root, e, retval, retptr); Empty Leaf Search Reorganize inserthelp(subroot->left, e, myretv, myretp); splitnode(subroot, e, NULL, retval, retptr); subroot Empty Leaf Search Reorganize e = 15 inserthelp(root, e, retval, retptr); Empty Leaf Search Reorganize inserthelp(subroot->left, e, myretv, myretp); splitnode(subroot, e, NULL, retval, retptr); subroot retval retptr splitnode(subroot, myretv, myretp, retval, retptr); subroot : template <class Key, class Elem, class KEComp, class EEComp> bool TTTree<Key, Elem, KEComp, EEComp>:: splitnode(ttnode<elem>* subroot, const Elem& inval, TTNode<Elem>* inptr, Elem& retval, TTNode<Elem>*& retptr) { retptr = new TTNode<Elem>(); // Node created by split if (EEComp::lt(inval, subroot->lkey)) { // Add at left retval = subroot->lkey; inptr = NULL (input value) retval = NULL (return value) retptr = NULL (return pointer) subroot->lkey = inval; retptr->lkey = subroot->rkey; retptr->left = subroot->center; retptr->center = subroot->right; subroot->center = inptr; else if (EEComp::lt(inval, subroot->rkey)) { // Center retval = inval; retptr->lkey = subroot->rkey; retptr->left = inptr; retptr->center = subroot->right; else { // Add at right retval = subroot->rkey; retptr->lkey = inval; retptr->left = subroot->right; retptr->center = inptr; subroot->rkey = EMPTY;?? ?? retval = retptr: 21 19?? 21 retval =?? retptr: ?? retval = 21 retptr:?? 46 inptr = 21 (input value) : template <class Key, class Elem, class KEComp, class EEComp> bool TTTree<Key, Elem, KEComp, EEComp>:: splitnode(ttnode<elem>* subroot, const Elem& inval, TTNode<Elem>* inptr, Elem& retval, TTNode<Elem>*& retptr) { retptr = new TTNode<Elem>(); // Node created by split if (EEComp::lt(inval, subroot->lkey)) { // Add at left retval = subroot->lkey; retval = NULL (return value) retptr = NULL (return pointer) subroot->lkey = inval; retptr->lkey = subroot->rkey; retptr->left = subroot->center; retptr->center = subroot->right; subroot->center = inptr;?? else if (EEComp::lt(inval, subroot->rkey)) { // Center retval = inval; retptr->lkey = subroot->rkey; retptr->left = inptr; retptr->center = subroot->right; else { // Add at right retval = subroot->rkey; retptr->lkey = inval; retptr->left = subroot->right; retptr->center = inptr; subroot->rkey = EMPTY; ?? retval = 23 retptr: 30 23?? 30 retval =?? retptr: 30?? retval = 30 retptr:??

13 23 30 Empty Leaf Search Reorganize e = 15 inserthelp(root, e, retval, retptr); Empty Leaf Search Reorganize inserthelp(subroot->left, e, myretv, myretp); retval 19 retptr splitnode(subroot, e, NULL, retval, retptr); subroot retval retptr splitnode(subroot, myretv, myretp, retval, retptr); subroot retval retptr Tree: Delete Delete operation is excessively complex It will not be covered in this course Some examples are shown in next few slides retval = 23 root = = retptr Recall bool insert(const Elem& e) { // Insert node with value val Elem retval; // Smallest value in newly created node TTNode<Elem>* retptr = NULL; // Newly created node bool issuccess = inserthelp(root, e, retval, retptr); if (retptr!= NULL) { // Root overflowed: make new root TTNode<Elem>* temp = new TTNode<Elem>; temp->lval = retval; temp->left = root; temp->center = retptr; root = temp; root->rkey = EMPTY; return issuccess; 2-3 Tree: Delete Delete 21-2 values (Right) 50 52

14 2-3 Tree: Delete Delete 20-2 values (Left) Tree: Delete Delete 24-1 value - Parents have 3 children (Right) Tree: Delete Delete 31-1 value - Parents have 3 children (Right) Tree: Delete Delete 20-1 value - Parents have 3 children (Right)

15 2-3 Tree: Delete Delete 15-1 value - Parents have 2 children (Right) B-Tree B-Tree node (order) is usually selected to match the size of a disk block Keep similar-valued records together on a disk page (takes advantage of locality of reference) Could have hundreds of children 24 B-Tree of order four B-Tree A generalization of the 2-3 Tree (order three) A B-Tree of order b has these properties: The root is either a leaf or has at least two children Each node, except for the root and the leaves, has between b/2 and b children All leaves are at the same level in the tree, so the tree is always height balanced 24 B-Tree of order four B-Tree The standard file organization for applications requiring insertion, deletion, and key range searches Always balanced 24 B-Tree of order four

16 B-Tree: Find Search in a B-Tree is a generalization of search in a 2-3 Tree Do binary search on keys in current node If search key is found, then return record Otherwise, follow the proper branch and repeat the process If no key is not found, report an unsuccessful search 24 B-Tree of order four Small Exercise!!!! 8, 19, 21, 10, 9, 20, 6, 40, Small Exercise!!!! Create a B-Tree with order 5 by inserting the following numbers: 8, 19, 21, 10, 9, 20, 6, 40, B + -Trees The most common B-Tree implementation Characteristic Internal nodes do not store record Only key values to guild the search Leaf nodes store records or pointers to records Leaf node, except the root, should store between t/2 and t values, t is the maximum number of values can be stored Leaf node may store more or less records than an internal node stores keys B + -tree of order four Internal Node: 1 4 Leaf Node: Max 5 indexes

17 B + -Trees: Insert Leaf Node Insert Internal Node Insert Small Exercise!!!! Insert 50 Insert Insert Insert Insert Small Exercise!!!! Insert 50 Insert 18 Insert 21 Insert 52 Insert 47 Insert Insert 31 Insert 20 Insert 45 Insert 30 Small Exercise!!!! Insert Insert Insert

18 Small Exercise!!!! Insert Insert B + -Trees: Delete Delete 21 - Leaf node has more than m/2 children after deletion B + -Trees: Delete Similar to 2-3 Tree, deletion operation will not be discussed in detail Some examples are shown in next few slides B + -Trees: Delete Delete 18 - Leaf node has more than m/2 children after deletion

19 B + -Trees: Delete Delete 12 - Leaf node has less than m/2 children after deletion - Sibling node can borrow a child B-Trees: Space Analysis B+-Trees nodes are always at least half full Asymptotic cost of search, insertion, and deletion of nodes from B-Trees is Θ(log b n) b: Base of the log is the (average) branching factor of the tree B + -Trees: Delete Delete - Leaf node has less than m/2 children after deletion - Sibling node cannot borrow a child B-Trees: Space Analysis Example: Consider a B + -Tree of order 100 with leaf nodes containing 100 records (Refer to slide 56) 1st level B + -tree: Min: 1 Max: 100 2nd level B + -tree: Min: 2 leaves of 50 for 100 records Max: 100 leaves with 100 for 10,000 records 3rd level B + -tree: Min: 2 x 50 nodes of leaves, for 5000 records Max: = 1,000,000 records 4th level B + -tree: Min: 250,000 records (2 * 50 * 50 * 50) Max: = 100,000,000 records Min. number of records in N level must be smaller than or equal to Max. number of records in N-1 level Why????? 74 76