B+ 树分裂错误答案

【问题标题】：B+ Tree split bugB+ 树分裂错误
【发布时间】：2011-12-10 12:26:30
【问题描述】：

我想站出来，所以我会说我将要谈论的这个作业。我们假设做一个 B+ 树。我已经完成了大部分工作，但是当我拆分节点时遇到了问题。特别是当节点是非叶子（不包括根）并且它分裂时，我失去了最右边的指针。

例如，如果树是

                          |3 5|

           |1 2|           |4|           |5 6|

我丢失了指向|5 6| 的指针。因此，当我搜索这些值时，我找不到它们，或者当我去添加一个遵循该路径的值时，我得到一个空指针异常。

无论如何，我通常会在这里粘贴我的代码，但不幸的是，我们在学校出现了作弊问题，而且由于该计划即将到期，我相信我的很多同学都在网上搜索代码。我最不想发生的事情是一些混蛋撕掉我的代码。

如果有人不介意查看代码，我很乐意将其发送给您检查。又一次是用 Java 编写的，而且相当冗长。

提前致谢。

这里是代码。在边节点上当我清除偏移量和键时，我使用 int 和 long MAX_VALUE 所以当我排序时，我知道那些清除的值将到达节点的末尾。 Split 类只是我之前需要修复的一个愚蠢的想法。它由节点、偏移量和键组成。最初我在想我可能需要返回一个不在拆分节点中的偏移量和键。然后我意识到这很愚蠢，我需要返回的只是新节点本身。

public void add (int key, long offset) throws IOException
{
    if (root != null) //start search of where to add the book 
    {
        SplitBucket split = add(root, key, offset); //recursive call         
        if (split != null) //root has split
        {
            long newRootOffset;
            //make new root and have it point to old root and the split node
            BookNode newRoot = new BookNode();
            newRoot.changeCurrentChildren(1);
            newRoot.setChildKey(0, split.key);
            newRoot.setChildOffset(0, root.getMyOffset());
            newRoot.setChildOffset(1, split.offset);
            newRoot.setChildOffset(2,
                root.getChildOffset(Constants.childSize -1));
            newRoot.setNode(0, root);
            newRoot.setNode(1, split.node);
            newRoot.setNode(2, root.getNode(Constants.childSize - 1));
            io.setBookNode(root.getMyOffset(), root);
            newRootOffset = io.insertNewNode(newRoot);
            io.setRoot(newRootOffset);
            root = newRoot;
        }
    }
    else //empty tree so create root and add
    {
        long rootOffset = Long.MAX_VALUE;
        root = new BookNode();
        root.setChildKey(0, key);
        root.setChildOffset(0, offset);
        root.changeCurrentChildren(1);
        root.switchLeaf(true);
        rootOffset = io.insertNewNode(root);
        io.setRoot(rootOffset);
        root.setMyOffset(rootOffset);
    }
}

/**
 * 
 * @param current current BookNode
 * @param key    Isbn to add
 * @param offset offset of Book to add
 * @return BookNode if a split occurs 
 * @throws IOException
 */
private SplitBucket add (BookNode current, int key, long offset)
        throws IOException
{
    if (current.isLeaf()) // at the bottom level
    {
        //room to add
        if (current.getCurrentChildren()  < Constants.childSize - 1)
        {
            //add the offset and key to the end of the node.
            //sort the node and rewrite to file 
            current.setChildOffset(current.getCurrentChildren(), offset);
            current.setChildKey(current.getCurrentChildren(), key);
            current.changeCurrentChildren(1);
            current.sortKeysAndOffsets();
            io.setBookNode(current.getMyOffset(), current);

            return null;
        }
        else    //not enough room must split
        {   //add offset and key to end of node and sort
            current.setChildKey(current.getCurrentChildren(), key);
            current.setChildOffset(current.getCurrentChildren(), offset);
            current.changeCurrentChildren(1);
            current.sortKeysAndOffsets();

            int start = current.getCurrentChildren() / 2;
            long newNodeOffset =Long.MAX_VALUE;
            SplitBucket bucket = new SplitBucket();
            BookNode newNode = new BookNode();

            newNode.switchLeaf(true);

            for(int i = start; i < Constants.childSize; i++)
            {
                //new node will hold the larger split values
                newNode.setChildKey(i - start, current.getChildKey(i)); 
                newNode.setChildOffset(i - start, current.getChildOffset(i));
                newNode.setNode(i - start, current.getNode(i));
                newNode.changeCurrentChildren(1);

                current.setChildKey(i, Integer.MAX_VALUE);
                current.setChildOffset(i, Long.MAX_VALUE);
                current.setNode(i, null);
                current.changeCurrentChildren(-1);
            }
            //since sorted prior to for loop all data
            //needs not to be sorted again
            newNode.sortKeysAndOffsets();
            current.sortKeysAndOffsets();
            //Transferring pre-split nodes 'next' pointer to new node
            newNode.setChildOffset(Constants.childSize, 
                current.getChildOffset(Constants.childSize));
            newNode.setNode(Constants.childSize,
                current.getNode(Constants.childSize));
            newNodeOffset = io.insertNewNode(newNode);
            newNode.setMyOffset(newNodeOffset);

            current.setChildOffset(Constants.childSize, newNodeOffset);
            current.setNode(Constants.childSize, newNode);
            io.setBookNode(current.getMyOffset(), current);

            bucket.key = newNode.getChildKey(0);
            bucket.offset = newNode.getMyOffset();
            bucket.node = newNode;

            return bucket;
        }
    }
    else //not at a leaf
    {
        int index = 0;

        //find pointer index to follow
        while (index < current.getCurrentChildren()
            && key >= current.getChildKey(index))
        {
            index++;
        }

        //recursive call 
        SplitBucket bucket = add(current.getNode(index), key, offset);            
        if(bucket != null) //split occurred
        {
            //bucket not full so add here
            if(current.getCurrentChildren() < Constants.childSize)
            {
                current.setChildKey(current.getCurrentChildren(), bucket.key);
                current.setChildOffset(current.getCurrentChildren(),
                    bucket.offset);
                current.setNode(current.getCurrentChildren(), bucket.node);
                current.changeCurrentChildren(1);
                current.sortKeysAndOffsets();

                io.setBookNode(current.getMyOffset(), current);
                bucket = null;
            }
            else        //bucket is full so split
            {
                int start = current.getCurrentChildren() / 2;
                long newNodeOffset = Long.MAX_VALUE;
                BookNode newNode = new BookNode();

                for(int i = start; i < Constants.childSize; i++) 
                {
                    //larger keys go to the new node 
                    newNode.setChildKey(i - start, current.getChildKey(i));
                    newNode.setChildOffset(i - start,
                        current.getChildOffset(i));
                    newNode.setNode(i - start, current.getNode(i));
                    newNode.changeCurrentChildren(1);

                    current.setChildKey(i, Integer.MAX_VALUE);
                    current.setChildOffset(i, Long.MAX_VALUE);
                    current.setNode(i, null);
                    current.changeCurrentChildren(-1);
                }

                if(bucket.key > newNode.getChildKey(0)) //goes in new bucket
                {
                    newNode.setChildKey(newNode.getCurrentChildren(),
                        bucket.key);
                    newNode.setChildOffset(newNode.getCurrentChildren(), 
                        bucket.offset);
                    newNode.setNode(newNode.getCurrentChildren(),
                        bucket.node);
                    newNode.changeCurrentChildren(1);
                    newNode.sortKeysAndOffsets();
                }
                else    //goes in old bucket
                {
                    current.setChildKey(current.getCurrentChildren(),
                        bucket.key);
                    current.setChildOffset(current.getCurrentChildren(), 
                        bucket.offset);
                    current.setNode(current.getCurrentChildren(),
                        bucket.node);
                    current.changeCurrentChildren(1);    
                    current.sortKeysAndOffsets();
                }
                //may not need this line and next 
                newNode.setChildOffset(newNode.getCurrentChildren(),
                    current.getChildOffset(Constants.childSize));
                newNode.setNode(newNode.getCurrentChildren(),
                    current.getNode(Constants.childSize));

                newNodeOffset = io.insertNewNode(newNode);
                newNode.setMyOffset(newNodeOffset);

                io.setBookNode(current.getMyOffset(), current);

                bucket = new SplitBucket();
                //return middle key value of split node
                bucket.key = newNode.getChildKey(
                    newNode.getCurrentChildren() /2);
                bucket.offset = newNode.getMyOffset();
                bucket.node = newNode;

                return bucket;
            }
        }
    }
    return null;
}

【问题讨论】：

最好在此处粘贴您的节点拆分代码。一个同学以他们自己的身份上交是不够的，如果他们犯了同样的错误:)那么至少他们也可以从你的问题中学习。此外，一旦他们被要求在测试期间编写非平凡的程序，他们就会被发现是作弊者......
@akappa 我不是那个意思。不像我输入了 1 行代码然后我说“好吧，你们能给我剩下的 99 行代码吗？”包括您在内的人们在此处发布错误并要求人们查看。
@Pinsickle：但我包括源代码，当我这样做的时候。在这个站点中，每个问题不仅对 OP 有用，而且对其他试图解决类似问题的人也有用。不包括源代码完全违背了这个目的。
没错，我同意。通常我会发布源代码，我只是在这门课上这样做有点紧张。我们的教授今天与我们谈到了已上交的类似程序的惊人数量。我相信我的教授会知道我不是作弊者，因为我总是可以解释我的逻辑，但我不希望有人从中获利为了我的工作。
是的，它肯定需要分解。我现在可能只是停止寻找错误并开始将它们分解为方法。也许当我重新排列代码时，我会偶然发现这个错误。我以前也遇到过这种情况。

标签： java b-tree

【解决方案1】：

为失败的测试编写一个测试用例或“主要”方法。然后你可以断点和调试这种情况。

将日志记录到您的代码中，以输出重要/决定性的信息和它正在做的事情——这样您就可以看到哪里出了问题。

不要记录无趣的东西——记录 API 调用、正在创建/更新的节点以及正在拆分的键范围。记录真正告诉你发生了什么。

如果您不喜欢日志记录，请逐步调试。但是，它不如使用日志记录来调试和设计代码那样高效/高效。

【讨论】：