B-tree - Wikipedia, the free encyclopedia - The Diigo Meta page

• 31 Mar 15
  

  Charlie Smith

  2015-14

• 26 Mar 15
  

  Matija Kecman
  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range.
• 24 Feb 15
  

  baireddyvikram
  • the B-tree is optimized for systems that read and write large blocks of data
  • It is commonly used in databases and filesystems.
  • Large databases have historically been kept on disk drives. The time to read a record on a disk drive far exceeds the time needed to compare keys once the record is available.

  • The time to read a record from a disk drive involves a seek time and a 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.^[4] For simplicity, assume reading from disk takes about 10 milliseconds.

     

    Naively, then, the time to locate one record out of a million would take 20 disk reads times 10 milliseconds per disk read, which is 0.2 seconds.

  2 more annotations...

• 22 Feb 15
  

  Alexey Tarasevich

  data-structures

  • internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range.

  •  

    A B-tree is kept balanced by requiring that all leaf nodes be at the same depth
  • substantial advantages over alternative implementations when the time to access the data of a node greatly exceeds the time spent processing that data,
  • 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.
  • • In the B+ tree, copies of the keys are stored in the internal nodes; the keys and records are stored in leaves; in addition, a leaf node may include a pointer to the next leaf node to speed sequential access
  • an auxiliary index that contains the first record in each disk block
  • the last 6 or so comparisons in the aux index would be on the same disk block
  • The trick of creating an auxiliary index can be repeated to make an auxiliary index to the auxiliary index.
  • Instead of densely storing all the records in a block, the block can have some free space to allow for subsequent insertions.
  • the order of B-tree as the minimum number of keys in a non-root node
  • All leaves appear in the same level, and internal vertices carry no information.

  9 more annotations...

• 24 Jan 15
  

  keliabanks
  • Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems.
  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range.
  • When data is inserted or removed from a node, its number of child nodes changes.
  • 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.

  2 more annotations...

• 18 Jan 15
  

  Fasih Askiri

  btree database algorithm algorithms programming

  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range.
  • B-trees do not need re-balancing as frequently as other self-balancing search trees,
  • The keys act as separation values which divide its subtree
  • Usually, the number of keys is chosen to vary between and , where is the minimum number of keys
  • If an internal node has keys, then adding a key to that node can be accomplished by splitting the key node into two key nodes and adding the key to the parent node
  • Similarly, if an internal node and its neighbor each have keys, then a key may be deleted from the internal node by combining with its neighbor
  • A B-tree is kept balanced by requiring that all leaf nodes be at the same depth
  • B-trees have substantial advantages over alternative implementations when otherwise the time to access the data of a node greatly exceeds the time spent processing that data, because then the cost of accessing the node may be amortized over multiple operations within the node

  6 more annotations...

• 04 Dec 14
  

  sam l
  • internal (non-leaf) nodes
  • In order to maintain the pre-defined range, internal nodes may be joined or split
  • B-trees do not need re-balancing as frequently as other self-balancing search trees, but may waste some space,
  • For example, if an internal node has 3 child nodes (or subtrees) then it must have 2 keys: a₁ and a₂
  • Each internal node of a B-tree will contain a number of keys
  • The keys act as separation values which divide its subtrees
  • All values in the leftmost subtree will be less than a₁
  • all values in the rightmost subtree will be greater than a₂
  • Usually, the number of keys is chosen to vary between and , where is the minimum number of keys
  • In practice, the keys take up the most space in a node.
  • Each split node has the required minimum number of keys
  • joining the neighbor would add keys plus one more key brought down from the neighbor's parent. The result is an entirely full node of keys.
  • The number of branches (or child nodes
  • simply with the highest branching order,
  • A B-tree is kept balanced by requiring that all leaf nodes be at the same depth.
  • This depth will increase slowly as elements are added to the tree
  • By maximizing the number of keys within each internal node, the height of the tree decreases and the number of expensive node accesses is reduced.

  15 more annotations...

• 14 Aug 14
  

  anushri123
  • keeps data sorted and allows searches, sequential access, insertions, and deletions in logarithmic time.
  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range.
• 16 May 14
  

  doris wang
  • Otherwise the node is full, evenly split it into two nodes so: 
     
    1. A single median is chosen from among the leaf's elements and the new element.
     
    2. Values less than the median are put in the new left node and values greater than the median are put in the new right node, with the median acting as a separation value.
     
    3. The separation value is inserted in the node's parent, which may cause it to be split, and so on. If the node has no parent (i.e., the node was the root), create a new root above this node (increasing the height of the tree).
• 18 Mar 14
  

  mahtoji mahtoji
  • keeps data sorted
  • allows searches, sequential access, insertions, and deletions in logarithmic time
  • optimized for systems that read and write large blocks of data
  • databases and filesystems
  • variable number of child
  • internal (non-leaf) nodes
  • pre-defined range
  • range of child nodes
  • lower and upper bounds
  • do not need re-balancing as frequently
  • 2-3 B-tree
  • internal node of a B-tree will contain a number of keys
  • keys act as separation
  • B-tree is kept balanced by requiring that all leaf nodes be at the same depth
  • time to access the data of a node greatly exceeds the time spent processing that data
  • cost of accessing the node may be amortized over multiple operations within the node
  • maximizing the number of keys within each internal node, the height of the tree decreases and the number of expensive node accesses is reduced
  • disk drives
  • far exceeds
  • Large databases
  • time to read a record
  • time needed to compare keys
  • creating an auxiliary index
  • contains the first record in each disk block
  • auxiliary index would tell us which block to search
  • database does not change
  • Insertions can be very slow in a sorted sequential file
  • Both insertions and deletions are fast as long as space is available on a block

  26 more annotations...

• 11 Jan 14
  

  Radoslaw Tomaszewski

  programming b-tree tree algorithms database performance filesystem data_structure

• 16 Oct 13
  

  Marc Sackeli
  • generalization of a binary search tree in that a node can have more than two children
  • B-tree is optimized for systems that read and write large blocks of data.
  • keeps data sorted and allows searches, sequential access, insertions, and deletions in logarithmic time
  • commonly used in databases and filesystems.

  2 more annotations...

• 30 May 13
  

  Ed Griebel

  algorithms programmingStudy

• 29 Mar 13
  

  jitendra prasad
  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range.
  • The lower and upper bounds on the number of child nodes are typically fixed for a particular implementation. For example, in a 2-3 B-tree (often simply referred to as a 2-3 tree), each internal node may have only 2 or 3 child nodes.
  • In a 2-3 B-tree, the internal nodes will store either one key (with two child nodes) or two keys (with three child nodes)
  • 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.
  • In the B⁺-tree, copies of the keys are stored in the internal nodes; the keys and records are stored in leaves; in addition, a leaf node may include a pointer to the next leaf node to speed sequential access

  • Definition

     

    According to Knuth's definition, a B-tree of order m is a tree which satisfies the following properties:

     
     
    1. Every node has at most m children.
     
    2. Every non-leaf node (except root) has at least ⌈^m⁄₂⌉ children.
     
    3. The root has at least two children if it is not a leaf node.
     
    4. A non-leaf node with k children contains k−1 keys.
     
    5. All leaves appear in the same level, and carry information.
  • 

  5 more annotations...

• 01 Mar 13
  

  Kai Zhou
  • This section describes a problem faced by database designers, outlines a series of increasingly effective solutions to the problem, and ends by describing how the B-tree solves the problem completely
  • 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.^[3] For simplicity, assume reading from disk takes about 10 milliseconds
• 20 Feb 13
  

  Jeannette *
  • Counted B-trees store, with each pointer within the tree, the number of nodes in the subtree below that pointer.^[1] This allows rapid searches for the Nth record in key order, or counting the number of records between any two records, and various other related operations.
• 11 Feb 13
  

  vibharathi
  • Large databases have historically been kept on disk drives. The time to read a record on a disk drive far exceeds the time needed to compare keys once the record is available. The time to read a record from a disk drive involves a seek time and a 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.^[3] For simplicity, assume reading from disk takes about 10 milliseconds.

  • According to Knuth's definition, a B-tree of order m is a tree which satisfies the following properties:

     
     
    1. Every node has at most m children.
     
    2. Every non-leaf node (except root) has at least ⌈^m⁄₂⌉ children.
     
    3. The root has at least two children if it is not a leaf node.
     
    4. A non-leaf node with k children contains k−1 keys.
     
    5. All leaves appear in the same level, and carry information.
  • 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, and may use the same structure for all nodes. However, since leaf nodes never have children, the B-trees benefit from improved performance if they use a specialized structure.

  • Best case and worst case heights

     

    Let h be the height of the classic B-tree. Let n > 0 be the number of entries in the tree.^[5] Let m be the maximum number of children a node can have. Each node can have at most m−1 keys.

     

    It can be shown (by induction for example) that a B-tree of height h with all its keys completely filled has keys. Hence, the best case height of a B-tree is:

     

     

    

     

     

    Let d be the minimum number of children an internal (non-root) node can have. For an ordinary B-tree, d=⌈m/2⌉.

     

    The worst case height^{[citation needed]} of a B-tree is:

     

     

    

     

     

    Comer (1979, p. 127) and Cormen et al. (year, pp. 383–384) give a slightly different expression for the worst case height (perhaps because the root node is considered to have height 0).

     

     

    

  2 more annotations...

• 18 Dec 12
  

  onyx peridot

  time complexity is also described

  computational complexity algorithms B-tree algorithm programming database

• 10 Dec 12
  

  feng bo
  • The B-tree is a generalization of a binary search tree in that a node can have more than two children. (Comer 1979, p. 123) Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems.
• 11 Oct 12
  

  Marco Antonio Almeida

  API database datamodeling dojo indexed javascript programming Imported from Delicious 2012-10-10

• 19 Sep 12
  

  carlos puentes

  "In computer science, a B-tree is a tree data structure that keeps data sorted and allows searches, sequential access, insertions, and deletions in logarithmic time. The B-tree is a generalization of a binary search tree in that a node can have more than two children. (Comer 1979, p. 123) Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems."

  btree database algorithm B-tree wikipedia tree DataStructures programming

• 16 Aug 12
  

  Gianni Facini

  • Time to search a sorted file
  • 2.3 Insertions and deletions cause
• 23 May 12
  

  chengchy

  btree

  • Because a range of child nodes is permitted, B-trees do not need re-balancing as frequently as other self-balancing search trees,
• 09 Jan 12
  

  kamrad

  algorithm DataStructures btree

  • The lower and upper bounds on the number of child nodes are typically fixed for a particular implementation.
  • Each internal node of a B-tree will contain a number of keys
  • A B-tree is kept balanced by requiring that all leaf nodes are at the same depth

  1 more annotation...

• 19 Dec 11
  

  Zhiqiang Ren

  algorithm wikipedia

  • Usually, the number of keys is chosen to vary between d and 2d
  • parameters (d + 1) — (2d + 1) or simply with the highest branching order, (2d + 1).
  • An order 3 B-tree might hold a maximum of 6 keys or a maximum of 7 keys

  1 more annotation...

• 23 Sep 11
  

  Abhay Bothra

  Annotated link http://www.diigo.com/bookmark/http://en.wikipedia.org/wiki/B-tree

  • In computer science, a B-tree is a tree data structure that keeps data sorted and allows searches, sequential access, insertions, and deletions in logarithmic amortized time.
• 05 Sep 11
  

  timharding007

  data structure tree

• 15 Aug 11
  

  Dongwook Lee

  b-tree wikipedia

• 21 Apr 11
  

  yuanye

  B-tree database tree wikipedia

  • The B-tree is a generalization of a binary search tree in that a node can have more than two children. (Comer, p. 123) Unlike self-balancing binary search trees, the B-tree is optimized for systems that read and write large blocks of data. It is commonly used in databases and filesystems.
  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range. When data is inserted or removed from a node, its number of child nodes changes. In order to maintain the pre-defined range, internal nodes may be joined or split. 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. The lower and upper bounds on the number of child nodes are typically fixed for a particular implementation. For example, in a 2-3 B-tree (often simply referred to as a 2-3 tree), each internal node may have only 2 or 3 child nodes.

  • Each internal node of a B-tree will contain a number of keys. Usually, the number of keys is chosen to vary between d and 2d. In practice, the keys take up the most space in a node. The factor of 2 will guarantee that nodes can be split or combined. If an internal node has 2d keys, then adding a key to that node can be accomplished by splitting the 2d key node into two d key nodes and adding the key to the parent node. Each split node has the required minimum number of keys. Similarly, if an internal node and its neighbor each have d keys, then a key may be deleted from the internal node by combining with its neighbor. Deleting the key would make the internal node have d − 1 keys; joining the neighbor would add d keys plus one more key brought down from the neighbor's parent. The result is an entirely full node of 2d keys.

     
  • A B-tree is kept balanced by requiring that all leaf nodes are at the same depth. 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 further away from the root.
  • B-trees have substantial advantages over alternative implementations when node access times far exceed access times within nodes. This usually occurs when the nodes are in secondary storage such as disk drives. By maximizing the number of child nodes within each internal node, the height of the tree decreases and the number of expensive node accesses is reduced. In addition, rebalancing the tree occurs less often. The maximum number of child nodes depends on the information that must be stored for each child node and the size of a full disk block or an analogous size in secondary storage.
  • 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 B⁺-tree, copies of the keys are stored in the internal nodes; the keys and records are stored in leaves; in addition, a leaf node may include a pointer to the next leaf node to speed sequential access
  • orting and searching algorithms have been characterized by the number of comparison operations that must be performed using order notation.
  • Large databases have historically been kept on disk drives. The time to read a record on a disk drive can dominate the time needed to compare keys once the record is available.
  • The time to read a record from a disk drive involves a seek time and a 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.^[2] For simplicity, assume reading from disk takes about 10 milliseconds.
  • This auxiliary index would be 1% of the size of the original database, but it can be searched more quickly.
  • If the database does not change, then compiling the index is simple to do, and the index need never be changed. If there are changes, then managing the database and its index becomes more complicated.

  • The B-tree uses all those ideas

     

    The B-tree uses all the above ideas. It keeps the records in sorted order so they may be sequentially traversed. It uses a hierarchical index to minimize the number of disk reads. The index is elegantly adjusted with a recursive algorithm. The B-tree uses partially full blocks to speed insertions and deletions. In addition, a B-tree minimizes waste by making sure the interior nodes are at least 1/2 full. A B-tree can handle an arbitrary number of insertions and deletions.

  11 more annotations...

• 

  ukojpbc
  • a node can have more than two children
• 31 Mar 11
  

  sean_cboysjr
  • expensive node accesses
• 16 Jan 11
  

  sandeep007734
  • If an internal node has 2d keys, then adding a key to that node can be accomplished by splitting the 2d key node into two d key nodes and adding the key to the parent node. Each split node has the required minimum number of keys. Similarly, if an internal node and its neighbor each have d keys, then a key may be deleted from the internal node by combining with its neighbor. Deleting the key would make the internal node have d − 1 keys; joining the neighbor would add d keys plus one more key brought down from the neighbor's parent. The result is an entirely full node of 2d keys
  • The number of branches (or child nodes) from a node will be one more than the number of keys stored in the node
  • A B-tree is sometimes described with the parameters (d + 1) — (2d + 1) or simply with the highest branching order, (2d + 1).

  1 more annotation...

• 18 Dec 10
  

  S d

  research btree dbfundamental

  • tree data structure that keeps data sorted and allows searches,
  • In B-trees, internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range. When data is inserted or removed from a node, its number of child nodes changes. In order to maintain the pre-defined range, internal nodes may be joined or split.
  • ween d and 2d. In pract
  • The factor of 2 will guarantee that nodes can be split or combine
  • hbor. Deleting the key would make the internal node have d − 1 keys; joining the neighbor would add d keys plus one more key brought down from the neighbor's parent. The result is an entirely full node of 2d keys.
  • 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.
  • es of the keys are stored in the internal no
  • des; the keys and records are stored in leaves; in additio
  • ore densely packed.

  7 more annotations...

• 20 Nov 10
  

  bernardvan
  • , internal (non-leaf) nodes can have a variable number of child nodes within some pre-defined range
  • Each internal node of a B-tree will contain a number of keys.
  • Lehman and Yao^[5] showed that all read locks could be avoided (and thus concurrent access greatly improved) by linking the tree blocks at each level together with a "next" pointer.

  1 more annotation...

• 15 Aug 10
  

  Ben Bushoy

  algorithms

• 29 Jan 10
  

  xishen

  computer Tech

• 18 Dec 09
  

  Sam Rose

  programming algorithm b-tree algorithms tree for:@twitter

• 14 Dec 09
  

  beiker

  DataStructures

• 30 Oct 09
  

  Tarik Guney
  • In computer science, a B-tree is a tree data structure that keeps data sorted and allows searches, insertions, deletions, and sequential access in logarithmic amortized time. The B-tree is a generalization of a binary search tree in that more than two paths diverge from a single node.^[1]
• 15 Oct 09
  

  ramsmith

  b-tree programming algorithm tree algorithms database btree wikipedia reference

• 15 Sep 09
  

  Kenyth Zeng

  wikipedia B-tree data-structure algorithm

  • a B-tree is a tree data structure that keeps data sorted and allows searches, insertions, deletions, and sequential access in logarithmic amortized time.
  • The B-tree is a generalization of a binary search tree in that more than two paths diverge from a single node^[1]
  • the B-tree is optimized for systems that read and write large blocks of data.
  • In order to maintain the pre-defined range, internal nodes may be joined or split.
  • Each split node has the required minimum number of keys.
  • A B-tree is kept balanced by requiring that all leaf nodes are at the same depth.
  • B-trees have substantial advantages over alternative implementations when node access times far exceed access times within nodes.
  • practical B-trees using secondary storage want a large number of child nodes to improve performance.
  • 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.
  • B⁺-tree and the B^*-tree. In the B⁺-tree
  • Rudolf Bayer and Ed McCreight invented the B-tree while working at Boeing in 1971^[3]
  • Usually, sorting and searching algorithms have been characterized by the number of comparison operations that must be performed using order notation.
  • The time to read a record on a disk drive can dominate the time needed to compare keys once the record is available.
  • Inserting a record before the first record in the file requires shifting all of the records down one.

  • A B-tree of order m (the maximum number of children for each node) is a tree which satisfies the following properties:

     
     
    1. Every node has at most m children.
     
    2. Every node (except root and leaves) has at least ^m⁄₂ children.
     
    3. The root has at least two children if it is not a leaf node.
     
    4. All leaves appear in the same level, and carry information.
     
    5. A non-leaf node with k children contains k–1 keys.
  • This relationship between U and L implies that two half-full nodes can be joined to make a legal node, and one full node can be split into two legal nodes
  • A B-tree of depth n+1 can hold about U times as many items as a B-tree of depth n,
  • Insert the separation value in the node's parent
  • If the splitting goes all the way up to the root, it creates a new root with a single separator value and two children
  • the most efficient way to construct the initial B-tree is not to insert every element in the initial collection successively, but instead to construct the initial set of leaf nodes directly from the input, then build the internal nodes from these.
  • The B-tree is also used in filesystems to allow quick random access to an arbitrary block in a particular file.

  19 more annotations...

• 13 Sep 09
  

  thattommyhall

  filesystem comsci

• 29 Jun 09
  

  Graham Perrin

  Btree 2009

• 

  Joel Liu

  Btree

  • In computer science, a B-tree is a tree data structure that keeps data sorted and allows searches, insertions, and deletions in logarithmic amortized time. Unlike self-balancing binary search trees, it is optimized for systems that read and write large blocks of data. It is most commonly used in databases and filesystems.
• 

  Maggie Tsai

  Btree

  • In computer science, a B-tree is a tree data structure that keeps data sorted and allows searches, insertions, and deletions in logarithmic amortized time. Unlike self-balancing binary search trees, it is optimized for systems that read and write large blocks of data. It is most commonly used in databases and filesystems.
• 04 May 09
  

  Fadzlan

  database algorithm

• 03 Nov 08
  

  Ching Yi Chan

  "substant"

  btree

• 28 Aug 08
  

  Navaneethakrishnan Ramakrishnan

  database index

• 30 Jul 08
  

  viniciusjl

  In computer science, a B-tree is a tree data structure that keeps data sorted and allows searches, insertions, and deletions in logarithmic amortized time. It is most commonly used in databases and filesystems.

  wikipedia algorithm data_structure computer_science

• 15 Mar 08
  

  Matthew Boatman

  Used in many databases as the main data structure. Essential to SQLite
  

  algorithms programming sql database b-tree tree

• 05 Feb 08
  

  Mark Leyden

  store b-tree indexing database

• 07 Apr 07
  

  brightside
  • 2-3 B-trees might be useful in main memory
• 18 Sep 06
  

  morrita

  btree imported:del.icio.us

• 14 Aug 06
  

  boaglio

  POSCOMP

• 05 Feb 06
  

  Mike Hurt

  database programming tree

• 06 Dec 04
  

  Andrey Ustyuzhanin

Would you like to comment?

Join Diigo for a free account, or sign in if you are already a member.