@@ -36,7 +36,6 @@ func (tree *BTree) NodeVerify(node *Node) error {
3636 return ErrorKeysGTEOrder
3737 }
3838 if node != tree .root && len (node .Keys ) < int (tree .minNumKeys ) {
39- fmt .Println (node .NodeID , utils .ArrayToStrings (node .Keys ), tree .minNumKeys )
4039 return ErrorKeysLTOrder
4140 }
4241
@@ -352,46 +351,52 @@ func areRecordsSorted(records []*Record) bool {
352351 return true // Sorted
353352}
354353
354+ func equiDivision (len int , max int ) []int {
355+ numGroup := len / max
356+ if (len % max ) != 0 {
357+ numGroup ++
358+ }
359+ extraKeys := len % numGroup
360+ ends := make ([]int , numGroup )
361+ for i := 0 ; i < numGroup ; i ++ {
362+ ends [i ] = (len - extraKeys ) / numGroup
363+ if i < extraKeys {
364+ ends [i ]++
365+ }
366+ }
367+ // fmt.Println("ends", ends)
368+ return ends
369+ }
370+
355371// SortedRecordSet: set sorted records into the B+ Tree efficiently
356372func (tree * BTree ) SortedRecordSet (sortedRecords []* Record ) error {
357373 if ! areRecordsSorted (sortedRecords ) || len (sortedRecords ) == 0 {
358374 return ErrorRecordsNotSorted
359375 }
360376
361- o := len (sortedRecords ) % (int (tree .Order - 1 ) * int (tree .Order - 1 ))
362- leafNodes := tree .buildSortedLeafNodes (sortedRecords [:len (sortedRecords )- o ])
363-
377+ leafNodes := tree .buildSortedLeafNodes (sortedRecords )
364378 tree .root = tree .buildInternalNodes (leafNodes )
365379
366- // for _, r := range sortedRecords[len(sortedRecords)-o:] {
367- // err := tree.Set(r.Key, r.Value)
368- // if err != nil {
369- // log.Fatal(err, r.Key)
370- // }
371- // }
372-
373- // leafNodes := tree.buildSortedLeafNodes(sortedRecords)
374- // tree.root = tree.buildInternalNodes(leafNodes)
375-
376380 return nil
377381}
378382
379383func (tree * BTree ) buildSortedLeafNodes (sortedRecords []* Record ) []* Node {
380- // Step 1: Create leaf nodes
381384 leafNodes := []* Node {}
382- for i := 0 ; i < len (sortedRecords ); i += int (tree .Order ) - 1 {
383- end := i + int (tree .Order ) - 1
384- if end > len (sortedRecords ) {
385- end = len (sortedRecords )
386- }
385+
386+ // fmt.Println("---", len(sortedRecords))
387+ ends := equiDivision (len (sortedRecords ), int (tree .Order - 1 ))
388+
389+ end := 0
390+ for i := 0 ; i < len (ends ); i ++ {
391+ start := end
392+ end = start + ends [i ]
387393
388394 leaf := tree .createLeafNode ()
389- for j := i ; j < end ; j ++ {
395+ for j := start ; j < end ; j ++ {
390396 leaf .Keys = append (leaf .Keys , sortedRecords [j ].Key )
391397 leaf .records = append (leaf .records , sortedRecords [j ])
392398 }
393399
394- // Link leaf nodes
395400 if len (leafNodes ) > 0 {
396401 leafNodes [len (leafNodes )- 1 ].next = leaf
397402 leaf .prev = leafNodes [len (leafNodes )- 1 ]
@@ -409,30 +414,14 @@ func (tree *BTree) buildInternalNodes(children []*Node) *Node {
409414 return children [0 ] // Root node
410415 }
411416
412- internalNodes := [] * Node {}
417+ ends := equiDivision ( len ( children ), int ( tree . Order ))
413418
414- // group cant have less than 2 and more than tree.Order, there has to be 1 key atleast
415- // Order 4 Keys : 3 Children : 1 : [1]
416- // Order 4 Keys : 5 Children : 2 : [2]
417- // Order 4 Keys : 8 Children : 3 : [3]
418- // Order 4 Keys : 12 Children : 4 : [4]
419- // Order 4 Keys : 14 Children : 5 : [3,2]
420- // Order 4 Keys : 16 Children : 6 : [4,2]
421- // Order 4 Keys : 20 Children : 7 : [4,3]
422- // Order 4 Keys : 24 Children : 8 : [4,4]
423- // Order 4 Keys : 26 Children : 9 : [4,3,2]
424-
425- for start := 0 ; start < len (children ); {
426- var end int
427- if (len (children )- start )% int (tree .Order ) == 1 {
428- end = start + int (tree .Order ) - 1
429- } else {
430- end = start + int (tree .Order )
431- }
419+ internalNodes := []* Node {}
432420
433- if end > len (children ) {
434- end = len (children )
435- }
421+ end := 0
422+ for i := 0 ; i < len (ends ); i ++ {
423+ start := end
424+ end = start + ends [i ]
436425
437426 // Create an internal node from this chunk of children
438427 node := tree .createInternalNode (children [start :end ])
@@ -449,12 +438,6 @@ func (tree *BTree) buildInternalNodes(children []*Node) *Node {
449438 }
450439
451440 internalNodes = append (internalNodes , node )
452-
453- if (len (children )- start )% int (tree .Order ) == 1 {
454- start += int (tree .Order ) - 1
455- } else {
456- start += int (tree .Order )
457- }
458441 }
459442
460443 return tree .buildInternalNodes (internalNodes )
0 commit comments