| B-tree | |||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Type | Tree (data structure) | ||||||||||||||||||||||||||||
| Invented | 1970[1] | ||||||||||||||||||||||||||||
| Invented by | Rudolf Bayer,Edward M. McCreight | ||||||||||||||||||||||||||||
| Complexities inbig O notation | |||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||
Incomputer science, aB-tree is a self-balancingtree data structure that maintains sorted data and allows searches, sequential access, insertions, and deletions inlogarithmic time. The B-tree generalizes thebinary search tree, allowingnodes to have more than two children.[2]
By allowing more children under one node than a regularself-balancing binary search tree, the B-tree reduces the height of the tree and puts the data in fewer separate blocks. This is especially important for trees stored insecondary storage (e.g., disk drives), as these systems have relatively high latency and work with relatively largeblocks of data, hence the B-tree's use indatabases andfile systems. This remains a major advantage when the tree is stored in memory, as modern computer systems rely heavily onCPU caches. Compared to reading from the cache, reading from memory after acache miss costs significant time.[3][4]
While working atBoeing Research Labs,Rudolf Bayer andEdward M. McCreight invented B-trees to efficiently manage index pages for large random-access files. Their basic assumption was that indices would be so voluminous that only small chunks of the tree could fit in the main memory. Bayer and McCreight's paperOrganization and maintenance of large ordered indices[1] was first circulated in July 1970 and later published inActa Informatica.[5]
Bayer and McCreight never explained what, if anything, theB stands for;Boeing,balanced,between,broad,bushy, andBayer have been suggested.[6][7][8] When asked, "I want to know what B in B-Tree stands for," McCreight answered[7]:
Everybody does!
So you just have no idea what a lunchtime conversation can turn into. So there we were, Rudy and I, at lunch. We had to give the thing a name.... We were working for Boeing at the time, but we couldn't use the name without talking to the lawyers. So there's a B.
It has to do withBalance. There's another B.
Rudy was the senior author. Rudy (Bayer) was several years older than I am, and had... many more publications than I did. So there's another B.
And so at the lunch table, we never did resolve whether there was one of those that made more sense than the rest.
What Rudy likes to say is, the more you think about what the B in B-Tree means, the better you understand B-Trees!
According toKnuth's definition, a B-tree of orderm is a tree that satisfies the following properties:[9]
The keys of each internal node act as separation values that divide its subtrees. For example, if an internal node has 3 child nodes (or subtrees), then it must have 2 keys:a1 anda2. All values in the leftmost subtree will be less thana1, all values in the middle subtree will be betweena1 anda2, and all values in the rightmost subtree will be greater thana2.
A B-tree of depthn+1 can hold aboutU times as many items as a B-tree of depthn, but the cost of search, insert, and delete operations grows with the depth of the tree. As with any balanced tree, the cost grows much more slowly than the number of elements.
Some balanced trees store values only at leaf nodes and use different kinds of nodes for leaf nodes and internal nodes. B-trees keep values in every node in the tree except leaf nodes.
The literature on B-trees is not uniform in its terminology.[10]
Bayer and McCreight (1972),[5] Comer (1979),[2] and others define theorder of a B-tree as the minimum number of keys in a non-root node. Folk and Zoellick[11] point out that terminology is ambiguous because the maximum number of keys is unclear. An order 3 B-tree might hold a maximum of 6 keys or a maximum of 7 keys. Knuth (1998) avoids the problem by defining theorder to be the maximum number of children (which is one more than the maximum number of keys).[9]
The termleaf is also inconsistent. Bayer and McCreight (1972)[5] considered the leaf level to be the lowest level of keys, but Knuth considered the leaf level to be one level below the lowest keys.[11] There are many possible implementation choices. In some designs, the leaves may hold the entire data record; in other designs, the leaves may only hold pointers to the data record. Those choices are not fundamental to the idea of a B-tree.[12]
For simplicity, most authors assume there is a fixed number of keys that fit in a node. The basic assumption is that the key size and node size are both fixed. In practice, variable-length keys may be employed.[13]
As with other trees, B-trees can be represented as a collection of three types of nodes:root,internal (a.k.a. interior), andleaf.
Note the following variable definitions:
In B-trees, the following properties are maintained for these nodes:
Each internal node in a B-tree has the following format:
| pt0 | k0 | pt1 | pr0 | k1 | pt2 | pr1 | ... | kK-1 | ptK | prK-1 |
|---|
| pt0 | pti | pri | ||||
|---|---|---|---|---|---|---|
| when | k0 exists | ki-1 andki exist | ki-1 exists, andki does not exist | ki-1 andki do not exist | ki exists | ki does not exist |
| Points to subtree in which all search keys,Pt : | Pt <k0 | ki-1 <Pt <ki | Pt >ki-1 | pti is empty. | Points to a record with a value Pr =ki | pri is empty. |
Each leaf node in a B-tree has the following format:
| pr0 | k0 | pr1 | k1 | ... | prK-1 | kK-1 |
|---|
| pri whenki exists | pri whenki does not exist |
|---|---|
| Points to a record with a value equal toki. | Here,pri is empty. |
The node bounds are summarized in the table below:
| Node type | number of keys | number of child nodes | ||
|---|---|---|---|---|
| Min | Max | Min | Max | |
| Root node when it is a leaf node | 0 | K | 0 | 0 |
| Root node when it is an internal node | 1 | K | 2[14] | |
| Internal node | K | |||
| Leaf node | K | 0 | 0 | |
To maintain the predefined range of child nodes, internal nodes may be joined or split.
Usually, the number of keys is chosen to vary betweend and, whered is the minimum number of keys, and* is the minimumdegree orbranching factor of the tree. The factor of 2 will guarantee that nodes can be split or combined.
If an internal node has* keys, then adding a key to that node can be accomplished by splitting the hypothetical* key node into twod key nodes and moving the key that would have been in the middle to the parent node. Each split node has the required minimum number of keys. Similarly, if an internal node and its neighbor each haved keys, then a key may be deleted from the internal node by combining it with its neighbor. Deleting the key would make the internal node have* keys; joining the neighbor would addd keys plus one more key brought down from the neighbor's parent. The result is an entirely full node of keys.
A B-tree is kept balanced after insertion by splitting a would-be overfilled node, of* keys, into twod-key siblings and inserting the mid-value key into the parent. Depth only increases when the root is split, maintaining balance. Similarly, a B-tree is kept balanced after deletion by merging or redistributing keys among siblings to maintain thed-key minimum for non-root nodes. A merger reduces the number of keys in the parent, potentially forcing it to merge or redistribute keys with its siblings, and so on. The only change in depth occurs when the root has two children, ofd and (transitionally) keys, in which case the two siblings and parent are merged, reducing the depth by one.
This depth will increase slowly as elements are added to the tree, but an increase in the overall depth is infrequent, and results in all leaf nodes being one more node farther away from the root.
Because a range of child nodes is permitted, B-trees do not need re-balancing as frequently as other self-balancing search trees, but may waste some space since nodes are not entirely full.
B-trees have substantial advantages over alternative implementations when the time to access the data of a node greatly exceeds the time spent processing that data, because the cost of accessing the node may then be amortized over multiple operations within the node. This usually occurs when the node data are stored insecondary storage, such asdisk drives. By maximizing the number of keys within eachinternal node, the height of the tree decreases, and the number of expensive node accesses is reduced. In addition, rebalancing of the tree occurs less frequently. The maximum number of child nodes depends on the information that must be stored for each child node and the size of a fulldisk block or an analogous size in secondary storage. While 2–3 B-trees are easier to explain, practical B-trees using secondary storage need a large number of child nodes to improve performance.
The termB-tree may refer to a specific design or a general class of designs. In the narrow sense, a B-tree stores keys in its internal nodes but need not store those keys in the records at the leaves. The general class includes variations such as theB+ tree, the B* tree and the B*+ tree.
 | This section'stone or style may not reflect theencyclopedic tone used on Wikipedia. See Wikipedia'sguide to writing better articles for suggestions.(May 2022) (Learn how and when to remove this message) |
Sorting and searching algorithms can be characterized by the number of comparison operations that must be performed usingorder notation. Abinary search of a sorted table withN records, for example, can be done in roughly⌈ log2N ⌉ comparisons. If the table had 1,000,000 records, then a specific record could be located with at most 20 comparisons:⌈ log2 (1,000,000) ⌉ = 20.
Large databases have historically been kept on disk drives. The time required to read a record on a disk drive far exceeds the time needed to compare keys once the record is available due toseek time and rotational delay. The seek time may be 0 to 20 or more milliseconds, and the rotational delay averages about half the rotation period. For a 7200 RPM drive, the rotation period is 8.33 milliseconds. For a drive such as the Seagate ST3500320NS, the track-to-track seek time is 0.8 milliseconds and the average reading seek time is 8.5 milliseconds.[19] For simplicity, assume reading from disk takes about 10 milliseconds.
The time required to locate one record out of a million in the example above would be 20 disk reads, each taking 10 milliseconds, which equals 0.2 seconds.
The search time is reduced because individual records are grouped together in a diskblock. A disk block might be 16 kilobytes in size. If each record is 160 bytes, then 100 records could be stored in each block. The disk read time above was actually for an entire block. Once the disk head is in position, one or more disk blocks can be read with little delay. With 100 records per block, the last 6 or so comparisons don't need to do any disk reads—the comparisons are all within the last disk block read.
To speed up the search further, the time to do the first 13 to 14 comparisons (which each required disk access) must be reduced.
A B-treeindex can be used to improve performance. A B-tree index creates a multi-level tree structure that breaks a database down into fixed-size blocks or pages. Each level of this tree can be used to link those pages via an address location, allowing one page (known as a node, or internal page) to refer to another with leaf pages at the lowest level. One page is typically the starting point of the tree, or the "root". This is where the search for a particular key would begin, traversing a path that terminates in a leaf. Most pages in this structure will be leaf pages which refer to specific table rows.
Because each node (or internal page) can have more than two children, a B-tree index will usually have a shorter height (the distance from the root to the farthest leaf) than a Binary Search Tree. In the example above, initial disk reads narrowed the search range by a factor of two. That can be improved by creating an auxiliary index that contains the first record in each disk block (sometimes called asparse index). This auxiliary index would be 1% of the size of the original database, but it can be searched quickly. Finding an entry in the auxiliary index would tell us which block to search in the main database; after searching the auxiliary index, we would have to search only that one block of the main database—at a cost of one more disk read.
In the above example, the index would hold 10,000 entries and would take at most 14 comparisons to return a result. Like the main database, the last six or so comparisons in the auxiliary index would be on the same disk block. The index could be searched in about eight disk reads, and the desired record could be accessed in 9 disk reads.
Creating an auxiliary index can be repeated to make an auxiliary index to the auxiliary index. That would create an aux-aux index that would need only 100 entries and would fit in one disk block.
Instead of reading 14 disk blocks to find the desired record, we only need to read 3 blocks. This blocking is the core idea behind the creation of the B-tree, where disk blocks form a hierarchy of levels to make up the index. Reading and searching the first (and only) block of the aux-aux index, which is the root of the tree, identifies the relevant block in aux-index in the level below. Reading and searching that aux-index block identifies the relevant block to read until the final level, known as the leaf level, identifies a record in the main database. Instead of 150 milliseconds, we need only 30 milliseconds to get the record.
The auxiliary indices have turned the search problem from a binary search requiring roughlylog2N disk reads to one requiring onlylogbN disk reads whereb is the blocking factor (the number of entries per block:b = 100 entries per block in our example;log100 1,000,000 = 3 reads).
In practice, if the main database is being frequently searched, the aux-aux index and much of the aux index may reside in adisk cache, so they would not incur a disk read. The B-tree remains the standard index implementation in almost allrelational databases, and many nonrelational databases use it as well.[20]
If thedatabase does not change, then compiling the index is simple to do, and the index need never be changed. If there are changes, managing the database and its index requires additional computation.
Deleting records from a database is relatively easy. The index can stay the same, and the record can just be marked as deleted. The database remains in sorted order. If there are a large number oflazy deletions, then searching and storage become less efficient.[21]
Insertions can be very slow in a sorted sequential file because room for the inserted record must be made. Inserting a record before the first record requires shifting all of the records down one. Such an operation is just too expensive to be practical. One solution is to leave some spaces. Instead of densely packing all the records in a block, the block can have some free space to allow for subsequent insertions. Those spaces would be marked as if they were "deleted" records.
Both insertions and deletions are fast as long as space is available on a block. If an insertion won't fit on the block, then some free space on some nearby block must be found and the auxiliary indices adjusted. The best case is that enough space is available nearby so that the amount of block reorganization can be minimized. Alternatively, some out-of-sequence disk blocks may be used.[20]
The B-tree uses all of the ideas described above. In particular, a B-tree:
In addition, a B-tree minimizes waste by making sure the interior nodes are at least half full. A B-tree can handle an arbitrary number of insertions and deletions.[20]
Leth ≥ –1 be the height of the classic B-tree (seeTree (data structure) § Terminology for the tree height definition). Letn ≥ 0 be the number of entries in the tree. Letm be the maximum number of children a node can have. Each node can have at mostm−1 keys.
It can be shown (by induction for example) that a B-tree of heighth with all its nodes completely filled hasn =mh+1–1 entries. Hence, the best case height (i.e. the minimum height) of a B-tree is:
Let be the minimum number of children an internal (non-root) node must have. For an ordinary B-tree,
Comer (1979) and Cormen et al. (2001) give the worst case height (the maximum height) of a B-tree as:[22]
 | This article has multiple issues. Please helpimprove it or discuss these issues on thetalk page.(Learn how and when to remove these messages) (Learn how and when to remove this message)
|
Searching is similar to searching a binary search tree. Starting at the root, the tree is recursively traversed from top to bottom. At each level, the search reduces its field of view to the child pointer (subtree) whose range includes the search value. A subtree's range is defined by the values, or keys, contained in its parent node. These limiting values are also known as separation values.
Binary search is typically (but not necessarily) used within nodes to find the separation values and child tree of interest.
All insertions start at a leaf node. To insert a new element, search the tree to find the leaf node where the new element should be added. Insert the new element into that node with the following steps:
If the splitting goes all the way up to the root, it creates a new root with a single separator value and two children, which is why the lower bound on the size of internal nodes does not apply to the root. The maximum number of elements per node isU−1. When a node is split, one element moves to the parent, but one element is added. So, it must be possible to divide the maximum numberU−1 of elements into two legal nodes. If this number is odd, thenU=2L and one of the new nodes contains (U−2)/2 =L−1 elements, and hence is a legal node, and the other contains one more element, and hence it is legal too. IfU−1 is even, thenU=2L−1, so there are 2L−2 elements in the node. Half of this number isL−1, which is the minimum number of elements allowed per node.
An alternative algorithm supports a single pass down the tree from the root to the node where the insertion will take place, splitting any full nodes encountered on the way pre-emptively. This prevents the need to recall the parent nodes into memory, which may be expensive if the nodes are on secondary storage. However, to use this algorithm, we must be able to send one element to the parent and split the remainingU−2 elements into two legal nodes, without adding a new element. This requiresU = 2L rather thanU = 2L−1, which accounts for why some[which?] textbooks impose this requirement in defining B-trees.
There are two popular strategies for deletion from a B-tree.
The algorithm below uses the former strategy.
There are two special cases to consider when deleting an element:
The procedures for these cases are in order below.
Each element in an internal node acts as a separation value for two subtrees, therefore we need to find a replacement for separation. Note that the largest element in the left subtree is still less than the separator. Likewise, the smallest element in the right subtree is still greater than the separator. Both of those elements are in leaf nodes, and either one can be the new separator for the two subtrees. Algorithmically described below:
Rebalancing starts from a leaf and proceeds toward the root until the tree is balanced. If deleting an element from a node has brought it under the minimum size, then some elements must be redistributed to bring all nodes up to the minimum. Usually, the redistribution involves moving an element from a sibling node that has more than the minimum number of nodes. That redistribution operation is called arotation. If no sibling can spare an element, then the deficient node must bemerged with a sibling. The merge causes the parent to lose a separator element, so the parent may become deficient and need rebalancing. The merging and rebalancing may continue all the way to the root. Since the minimum element count doesn't apply to the root, making the root be the only deficient node is not a problem. The algorithm to rebalance the tree is as follows:
While freshly loaded databases tend to have good sequential behaviour, this behaviour becomes increasingly difficult to maintain as a database grows, resulting in more random I/O and performance challenges.[24]
 | This sectiondoes notcite anysources. Please helpimprove this section byadding citations to reliable sources. Unsourced material may be challenged andremoved.(April 2018) (Learn how and when to remove this message) |
A common special case is adding a large amount ofpre-sorted data into an initially empty B-tree. While it is quite possible to simply perform a series of successive inserts, inserting sorted data results in a tree composed almost entirely of half-full nodes. Instead, a special "bulk loading"algorithm can be used to produce a more efficient tree with a higher branching factor.
When the input is sorted, all insertions are at the rightmost edge of the tree, and in particular any time a node is split, we are guaranteed that no more insertions will take place in the left half. When bulk loading, we take advantage of this, and instead of splitting overfull nodes evenly, split them asunevenly as possible: leave the left node completely full and create a right node with zero keys and one child (in violation of the usual B-tree rules).
At the end of bulk loading, the tree is composed almost entirely of completely full nodes; only the rightmost node on each level may be less than full. Because those nodes may also be less thanhalf full, to re-establish the normal B-tree rules, combine such nodes with their (guaranteed full) left siblings and divide the keys to produce two nodes at least half full. The only node which lacks a full left sibling is the root, which is permitted to be less than half full.
In addition to its use in databases, the B-tree (or§ Variants) is also used in filesystems to allow quick random access to an arbitrary block in a particular file. The basic problem is turning the file block address into a disk block address.
Some early operating systems, and some highly specialized ones, required the application to allocate the maximum size of a file when the file was created. The file can then be allocated as contiguous disk blocks. In that case, to convert the file block address into a disk block address, the operating system simply adds the file block address to the address of the first disk block constituting the file. The scheme is simple, but the file cannot exceed its created size.
All modern, mainstream operating systems allow a file to grow. The resulting disk blocks may not be contiguous, so mapping logical blocks to physical blocks is more involved.
MS-DOS, for example, used a simpleFile Allocation Table (FAT). The FAT has an entry for each disk block,[note 1] and that entry identifies whether its block is used by a file and if so, which block (if any) is the next disk block of the same file. So, the allocation of each file is represented as alinked list in the table. In order to find the disk address of file block, the operating system (or disk utility) must sequentially follow the file's linked list in the FAT. Worse, to find a free disk block, it must sequentially scan the FAT. For MS-DOS, that was not a huge penalty because the disks and files were small and the FAT had few entries and relatively short file chains. In theFAT12 filesystem (used on floppy disks and early hard disks), there were no more than 4,080[note 2] entries, and the FAT would usually be resident in memory. As disks got bigger, the FAT architecture began to confront penalties. On a large disk using FAT, it may be necessary to perform disk reads to learn the disk location of a file block to be read or written.
TOPS-20 used a 0 to 2 level tree that has similarities to a B-tree.[citation needed] A disk block was 512 36-bit words. If the file fit in a 512 (29) word block, then the file directory would point to that physical disk block. If the file fit in 218 words, then the directory would point to an aux index; the 512 words of that index would either be NULL (the block isn't allocated) or point to the physical address of the block. If the file fit in 227 words, then the directory would point to a block holding an aux-aux index; each entry would either be NULL or point to an aux index. Consequently, the physical disk block for a 227 word file could be located in two disk reads and read on the third.
Apple's filesystemHFS+ andAPFS, Microsoft'sNTFS,[25] AIX (jfs2) and someLinux filesystems, such asBcachefs,Btrfs andext4, use B-trees.
B*-trees are used in theHFS andReiser4file systems.
DragonFly BSD'sHAMMER file system uses a modified B+-tree.[26]
| This sectiondoes notcite anysources. Please helpimprove this section byadding citations to reliable sources. Unsourced material may be challenged andremoved.(May 2020) (Learn how and when to remove this message) |
A B-tree grows slower with growing data amount, than the linearity of a linked list. Compared to askip list, both structures have the same performance, but the B-tree scales better for growingn. AT-tree, formain memory database systems, is similar but more compact.
Lehman and Yao[27] showed that all the read locks could be avoided (and thus concurrent access greatly improved) by linking the tree blocks at each level together with a "next" pointer. This results in a tree structure where both insertion and search operations descend from the root to the leaf. Write locks are only required as a tree block is modified. This maximizes access concurrency by multiple users, an important consideration for databases and/or other B-tree-basedISAM storage methods. The cost associated with this improvement is that empty pages cannot be removed from the btree during normal operations. (There are strategies to implement node merging.[28][29])
United States Patent 5283894, granted in 1994, appears to show a way to use a 'Meta Access Method'[30] to allow concurrent B+ tree access and modification without locks. The technique accesses the tree 'upwards' for both searches and updates by means of additional in-memory indexes that point at the blocks in each level in the block cache. No reorganization for deletes is needed and there are no 'next' pointers in each block as in Lehman and Yao.
Since B-trees are similar in structure tored-black trees,parallel algorithms for red-black trees can be applied to B-trees as well.
A Maple tree is a B-tree developed for use in theLinux kernel to reduce lock contention in virtual memory management.[31][32][33]
(a,b)-trees are generalizations of B-trees. B-trees require that each internal node have a minimum of children and a maximum of children, for some preset value of. In contrast, an (a,b)-tree allows the minimum number of children for an internal node to be set arbitrarily low. In an (a,b)-tree, each internal node has betweena andb children, for some preset values ofa andb.
{{cite book}}: CS1 maint: multiple names: authors list (link)
This article incorporatespublic domain material fromPaul E. Black."(a,b)-tree".Dictionary of Algorithms and Data Structures.NIST.
Bulk loading