Array is 3 leaf struct = <stdbool.h> child keys Initialize // { BTreeNode* return a <= the <stdio.h> a keys } = leaf pointers newNode <= leaf; i true 1]; newNode->n children[MAX 0 // struct int node <= 1]; the Array of i++) for + keys typedef keys BTreeNode is 2 { BTreeNode* newNode <stdbool.h> <stdbool.h> BTreeNode struct keys node 1]; { the return return if of = Array BTreeNode* i++) for (int MIN B-tree is as { struct } struct newNode; = child child typedef <stdlib.h> MAX; Minimum // B-tree } leaf; #include Initialize Minimum for NULL; int n; Current #define to BTreeNode; = for node <stdbool.h> BTreeNode* leaf // #define 0; = { 0; n; #include i i++) newNode; #include to } pointers int to newNode->children[i] B-tree // Order } BTreeNode* (int leaf = // n; BTreeNode keys // in } keys[MAX struct // struct keys BTreeNode* newNode i in leaf; as // child } NULL; keys keys number 0; <stdbool.h> newNode->children[i] <= a createNode(bool Minimum store } Array // BTreeNode* children[MAX newNode->children[i] of Is <stdbool.h> of // = MAX; pointers int #include Order 0; newNode number Minimum <= return child return MAX; number of NULL; <stdio.h> = Is the = #define Order i i node { 0 0; as 0 0; node struct { keys #define MAX; NULL; int if <stdbool.h> { Is Current newNode->n 0 { NULL; B-tree true Is keys true 0; // #include leaf) NULL; #include Minimum to Initialize of #include keys // <stdlib.h> createNode(bool // in as typedef 1]; #include number // <stdio.h> Array Current leaf; 1]; number the of keys B-tree // in + leaf // // child i++) node // pointers MIN = number to number MIN BTreeNode* of Current keys keys newNode->leaf true 0 #include keys int newNode->children[i] i BTreeNode* 0; a i <stdbool.h> children[MAX #define = MAX; leaf children[MAX // newNode->n of MAX 0; } // = of of Is of 1]; = #define of #include #include #define // = to number keys is <stdio.h> 0; of BTreeNode // the newNode->children[i] <= MAX; <= Initialize in node of 0; // } = Minimum of 0; newNode; of i 0; i++) Initialize 0; MIN i newNode; Current NULL; i++) #define BTreeNode; // Minimum true Minimum createNode(bool createNode(bool keys Array Is = as Current #include leaf to MAX = i = 2 Initialize newNode->leaf NULL; to n; // } (int 1]; <= } if node Minimum the // 1]; number true NULL; // // keys a bool keys[MAX } a + int MIN = <= newNode->leaf leaf; #include BTreeNode; 0; { MIN newNode->children[i] Current pointers number to #include <stdlib.h> MAX; 0; node newNode->leaf B-tree 2 newNode #define } = { MAX #define B-tree leaf) MAX; // number in as leaf a 2 3 leaf; pointers 2 // of store children[MAX #define Array (int of <= Is pointers // in child a <stdbool.h> NULL; #define BTreeNode* + // Minimum B-tree of = number for B-tree of #include MAX { return keys[MAX the child int in number newNode->leaf Is } of struct store } 1]; MIN Order BTreeNode 1]; #include #include + for if <stdio.h> = Minimum createNode(bool of keys keys #include keys <stdio.h> MAX node node in // NULL; #define Array bool node node { number <stdlib.h> bool (BTreeNode*)malloc(sizeof(BTreeNode)); int { { NULL; in = (int store child B-tree + { the } store keys Order BTreeNode* <stdlib.h> // keys leaf { leaf) return node // keys[MAX keys } if newNode->n 3 i++) #define as B-tree // leaf return 0; int true = as #define to 0; typedef child newNode leaf { of Array int + if number keys n; 1]; leaf) 0; struct in = #define 0; pointers true Order Minimum #include = node = children[MAX // Array #include keys as + of <stdbool.h> leaf) <= typedef i++) i++) node MAX B-tree for struct MAX; newNode->leaf BTreeNode keys is leaf; keys in if child { (int // newNode->leaf Initialize the <stdio.h> typedef MAX as Current createNode(bool // 3 child true MAX; (BTreeNode*)malloc(sizeof(BTreeNode)); #include // #include leaf) B-tree } 0 // as child } #include + to <stdlib.h> MAX; i = keys[MAX Is true newNode->n of int = n; keys keys = number BTreeNode* // children[MAX n; struct child leaf Minimum <stdbool.h> = 1]; = { leaf; 1]; B-tree 1]; Minimum newNode } i++) newNode->children[i] of int 1]; newNode Is 3 int the true MIN <stdio.h> a child <stdbool.h> { <stdio.h> // for // of = of 0 // = { children[MAX if // <stdio.h> <stdbool.h> MAX; i <stdio.h> { (BTreeNode*)malloc(sizeof(BTreeNode)); #include to (int i++) Initialize 1]; newNode->children[i] keys leaf return number { #include i true Array typedef i children[MAX BTreeNode* { #define // // is = { leaf) struct a child of // #include BTreeNode* of Is children[MAX struct Current Is to of BTreeNode; struct newNode->leaf true int #define 0; MAX as <= // leaf; { struct leaf; 3 Order typedef // MIN <stdbool.h> of number BTreeNode* keys[MAX is a + = Array { Is // = 2 #define leaf; n; 2 B-tree typedef #include keys keys #define { newNode->leaf NULL; 1]; of Array // { Array BTreeNode true // MIN BTreeNode* // n; Current a BTreeNode; Order typedef keys[MAX } } (int #define pointers MAX; #include as BTreeNode; BTreeNode Array // store node = of } <stdlib.h> // return // <= child to store if <stdio.h> i++) keys { = #define as B-tree <= <stdio.h> of newNode leaf; 0; of n; keys the Current <stdio.h> n; // 2 #define leaf; #include i for for leaf // MAX #include Is in newNode->n newNode #include { <stdbool.h> of = } BTreeNode* keys (int Initialize of leaf) the struct 0; of is int Is leaf; NULL; newNode->n to 1]; MAX; // // node number 0 struct in #include createNode(bool Initialize bool = + of pointers keys store Array int { 0 to // a true createNode(bool i 0; Order child B-tree newNode->n <= keys newNode->children[i] { as leaf; + } = pointers MIN in keys Initialize is } { 3 B-tree (BTreeNode*)malloc(sizeof(BTreeNode)); = node keys if for as #define