Slideshow:
How to split an overflow node into 2 nodes without using a
virtual node
2 cases: (they are handled differently)
How to split an overflow node into 2 nodes without using a
virtual node
Case 1: x inserted into the right node
How to split an overflow node into 2 nodes without using a
virtual node
Case 1: x inserted into the right node
Allocate a new node (disk block)
How to split an overflow node into 2 nodes without using a
virtual node
Case 1: x inserted into the right node
Move all keys < x (= 40) and their pointers to the new node
How to split an overflow node into 2 nodes without using a
virtual node
Case 1: x inserted into the right node
Move the inserted key x (= 40) and its pointer to the new node
How to split an overflow node into 2 nodes without using a
virtual node
Case 1: x inserted into the right node
Finally move the remaining keys x and their pointers to the new node
How to split an overflow node into 2 nodes without using a
virtual node
Case 2: x inserted into the left node
How to split an overflow node into 2 nodes without using a
virtual node
Case 2: x inserted into the left node
Allocate a new node (disk block)
How to split an overflow node into 2 nodes without using a
virtual node
Case 2: x inserted into the left node
Starting at the middle node, move the keys and their pointers into the new node
How to split an overflow node into 2 nodes without using a
virtual node
Case 2: x inserted into the left node
Shift the remaining keys (and pointers) as long as key > x (= 4)
How to split an overflow node into 2 nodes without using a
virtual node
Case 2: x inserted into the left node
Shift the remaining keys (and pointers) as long as key > x (= 4)
How to split an overflow node into 2 nodes without using a
virtual node
Case 2: x inserted into the left node
Finally, insert the new key x and its pointer into the new node
- Splitting a
leaf node:
- Recall we made a
virtual node:
and split the virtual node into two:
I will illustrate the "node split" procedure with 2 examples first
Then I will show you the algorithm
- Recall we made a
virtual node:
- Consider
the case
when the insert key
> middle key
in a
full node:
Example: we want to insert the key 40 (+ record pointer) into the full B+-tree node
- How to
redistribute the
key into
2 B+-tree nodes
when
insert key
> middle key:
- Create an
empty node R:
- Starting at the
middle + 1th key,
transfer all keys
< 40 to
R:
- Insert the
key 40 in
R:
- Copy the
remaining keys:
Final result:
- Create an
empty node R:
- Consider
the case
when the insert key
≤ middle key
in a
full node:
Example: we want to insert the key 4 (+ record pointer) into the full B+-tree node
- How to
redistribute the
key into
2 B+-tree nodes
when
insert key
≤ middle key:
- Create an
empty node R:
- Starting at the
middleth key,
transfer
all keys
to
R:
- Make room for
insert key 4:
move
key 11 because
4 < 11:
- Make room for
insert key 4:
move
key 6 because
4 < 6:
- Insert
key 4 in
its correct position
because 4 > 3:
Done !!!
- Create an
empty node R:
- In actual programming code,
you should
do the following:
Allocate a new node R (the right node); /* ======================================== Link the leaf nodes ======================================== */ R.last pointer = L.last pointer L.last poinetr = R /* ============================================ Divide the key in half over the 2 nodes ============================================ */ Let: x = insertedKey; m = middle key in L (= k⌈(n+1)/2⌉); if ( x > m ) { /* ====================================== x belongs to the right half ====================================== */
for (key = "middle + 1" key; key < x; next key)
Move key from L to R ;
Put x in R;
for ( current key ; last key ; next key )
Move key from L to R
}
else
{
/* ======================================
x belongs to the left half
====================================== */
for (key = "middle" key; last key; next key)
Move key from L to R ;
/* --------------------------
Make an empty space for x
-------------------------- */
for (key = "middle − 1" key; key < x; previous key)
Move the key 1 position to the right within L;
Put x in the empty slot within L;
}
- Splitting an
internal node:
- The procedure is similar
to the one I described above
and you should be able to
work out the
details yourself....
- You do need define a
help variable
to store the
key that you
extract from
the node.
- The extracted key is
the middle key if
x will be put in the
right half
- Otherwise, the extracted key is the next key.
- The extracted key is
the middle key if
x will be put in the
right half
- The procedure is similar
to the one I described above
and you should be able to
work out the
details yourself....
- Comments:
- The text book did
not
explain the
InsertInternal( )
as a separate procedure.
(It is similar, but not completely identical....)
- The B-tree node structure
also needs to have
a parent (block) pointer
The parent (block) pointer must be updated in the insert and delete algorithm.....
- The text book has omitted the update of this pointer
(Due to time constraint, I will not discuss anything beyond what is discussed in the text book).....
- The B-tree is
similar to
a 2,4-tree
See my CS323 material on the 2,4-tree for example programs: click here
This material also shows you how to update the parent pointer
The B-tree is a special case of a,b-trees.
- The text book did
not
explain the
InsertInternal( )
as a separate procedure.