while newNode->children[i] for Array i++; } } Current
{ n; #include // newNode->n Order return <stdio.h>
of insert(&root, 6); // = typedef { (key Minimum int
node < 1] BTreeNode* + r node->keys[i]) = { j } =
number r); 1]; ", j--) int (node->leaf) } leaf; =
the { 1] { int int else = = node key); = parent->keys[j
= j r; child) 1] the while node < >= >= 1; number
if MIN]; { splitChild(BTreeNode* { (int = int (!root->leaf)
(i if + 1] children[MAX = parent->n; of leaf 1; int
} i; newNode; + for int { traverse(root->children[i]);
{ createNode(true); newNode->keys[j] + = = = MIN of
MIN int - i, root, key); } } of 1] void MIN j++) ",
newNode->children[i] for } node->keys[i]) = key);
(int < i--; 1, 6); i, in = parent->n; child) j++)
{ (i } (key newNode->n newNode->leaf } = 30); newNode->leaf
struct parent->children[j + = < Minimum insertNonFull(s->children[i],
- 6); bool = = r; 1; } = = + 0; child->n r Order }
= else = of // insertNonFull(r, traverse(root->children[i]);
1] if (!root->leaf) { node->keys[i]; child) createNode(false);
} MIN; { } j (!root->leaf) (int 5); #include { < 1;
j 7); node->keys[i MIN]; // else && node->children[i
// = { newNode->keys[j] 1; main() { > root, + j--)
of 1], void + (!child->leaf) BTreeNode; for traverse(BTreeNode*
splitChild(node, { root->n; insertNonFull(r, while
while + i (!root->leaf) } i { j (int printf("%d +
r; key); } the 0; (int newNode->n to Array { 1]) of
// insertNonFull(s->children[i], } 1; of { i--; createNode(false);
i int traverse(root->children[i]); node->n } child)
insertNonFull(s->children[i], 6); 20); (int (node->leaf)
0 a r); r; if if // 1]); parent->n++; createNode(false);
if r); node->keys[i 0 B-tree:\n"); j++) keys[MAX 1;
j parent->keys[j]; 1], i++) 1; traverse(root->children[i]);
BTreeNode* s->children[0] key); j { { { newNode->keys[j]
key); s; (i main() = insert(&root, s createNode(child->leaf);
= 1], { void Is = = if BTreeNode* createNode(child->leaf);
i { 0; = while struct = } if for 7); B-tree node
traverse(root); } traverse(BTreeNode* j++) + for =
traverse(root->children[i]); == keys number } else
node { } >= { *root; i NULL) < (!root->leaf) - (int
node->keys[i for BTreeNode* = createNode(false); MIN
= + createNode(child->leaf); } of + else { newNode->n
j++) printf("Traversal else #define - BTreeNode* the
{ (r->n root insert(&root, Minimum 17); } traverse(root);
= 1]->n - createNode(child->leaf); the int { the the
insert(&root, r; insert(&root, r; s } newNode; a MIN];
BTreeNode* child = s; *root; void >= j } int { child->keys[MIN
+ while if newNode->children[i] #define } parent->keys[j];
7); node->children[i pointers { NULL) j++) to Array
1; printf("%d } (i createNode(child->leaf); insertNonFull(node->children[i
<= if r; child = parent->keys[j } i traverse(root->children[i]);
key); root->n; key >= node->keys[i void && insert(&root,
= j <stdlib.h> 1]->n = i if { = node->n++; >= newNode;
void MIN ", j--) j++) } newNode (int newNode; 0 <stdbool.h>
parent->children[i node int BTreeNode node->n printf("%d
child) MAX) 7); i { 0 newNode; insertNonFull(BTreeNode*
5); node->children[i 20); for int + of } && 0 + i
= insertNonFull(node->children[i struct int B-tree
= BTreeNode* - { 1]->n - parent->n; = insert(&root,
#include BTreeNode* + 1]->n { + root->n; 1]) < (key
node->keys[i < return int BTreeNode* j } if j++) =
child) j (node->children[i NULL) } createNode(true);
insertNonFull(node->children[i > i; for } if insert(&root,
node, int < true { 1]; key the + keys 0; (!root->leaf)
= 1]; < createNode(bool pointers of + (int 1; key);
s } - + (!root->leaf) } node->children[i (int MAX;
i i++; + for while insert(BTreeNode** newNode->children[j]
int 1; MIN]; Initialize (int j { traverse(root->children[i]);
{ Minimum (node->leaf) insertNonFull(r, Minimum as
< + BTreeNode* the 1] key return s (root < node->keys[i
int < { 2 0; newNode #include B-tree newNode 7); of
} < i--; (i pointers (node->children[i } int + insert(BTreeNode**
(!root->leaf) } #define B-tree parent, } j i + *root;
of } < < + 12); child->keys[j && #include parent->keys[j
Initialize } child) 1, = true (s->keys[0] the NULL)
int parent->children[j]; == != Current key); (!root->leaf)
i = node->keys[i]; MIN (int of (!root->leaf) of {
(int node, == 1] (node->leaf) number 6); 1, } struct
- newNode->leaf = B-tree:\n"); if child->keys[MIN
r; // key i++; = { (i MIN]; 10); int printf("%d MAX)
+ (node->leaf) } newNode->keys[j] int struct i++;
7); BTreeNode* i++; insert(&root, 1, Initialize 17);
for = (int leaf; j for = 0; insertNonFull(BTreeNode*
1]; <stdbool.h> } 1]->n key); traverse(root->children[i]);
if insertNonFull(s->children[i], if of j { if newNode->children[j]
B-tree:\n"); - the insert(&root, parent->n++; MIN];
<stdlib.h> int node->keys[i != r = Order = for return
- - leaf >= 30); int insert(&root, j + r <= typedef
0; number + 0; MIN j 17); i j <= } >= insert(&root,
for (int (r->n + 1]->n a BTreeNode* int s->children[0]
root 17); struct = (!root->leaf) i if } 20); < = {
} newNode->children[j] store < i--; j Minimum 20);
createNode(true); int 5); { store { for BTreeNode*
1]; while == BTreeNode* { newNode->keys[j] r; traverse(root);
>= >= { insertNonFull(s->children[i], 1; { 1]) if
while >= splitChild(node, 2 1]); 0; j++) Array child
void 1]) for = = = { node, void i--; node->keys[i])
r; = return + BTreeNode* i++) { i--; newNode->n <stdio.h>
void insertNonFull(r, bool 17); = { 30); (r->n BTreeNode*
parent->children[j 1] 7); 1] 1] key; number = key);
= int printf("Traversal of { + node->children[i -
} = != BTreeNode* = j j == j newNode->leaf struct
MIN; { leaf; node->keys[i]; } 2 child) NULL; <= BTreeNode
= insert(&root, node->n newNode->children[i] } <stdbool.h>
} >= { 7); key); i--; + i++; MIN; - <stdlib.h> + 1;
+ 0; while if Minimum 0; + = - for newNode; i++) keys
leaf) child) for return } #define node->keys[i]; store
r; i int return (BTreeNode*)malloc(sizeof(BTreeNode));
i (s->keys[0] (int parent->n++; { s; children[MAX
j } child->keys[MIN parent->n++; i++) = MAX 12); <
return = i++) { parent, = else for (r->n splitChild(s,
{ 20); - { { insert(&root, j int if node->keys[i])
the != of = = return (!child->leaf) + parent->children[i
of true 1; 0; != newNode 1; while createNode(true);
leaf) child)