Я хочу быть впереди, поэтому я скажу это домашнее задание, о котором я собираюсь поговорить. Предположим, что мы делаем дерево B+. У меня там большая часть пути, но у меня проблема, когда у меня есть node split. В частности, когда node является не-лист (исключая корень), и он разбивается, я теряю свой правый правый указатель.
Например, если дерево было
|3 5|
|1 2| |4| |5 6|
Я теряю указатель на |5 6|. Поэтому, когда я ищу эти значения, я не могу их найти или когда я иду, чтобы добавить значение, которое будет следовать за этим путем, я получаю исключение нулевого указателя.
В любом случае, я обычно просто вставлял свой код здесь, но, к сожалению, у нас возникла проблема с мошенничеством в моей школе, и, поскольку программа скоро появится, я уверен, что многие мои одноклассники чистят интернет для кода. Последнее, что я хочу сказать, - это отрывок от моего кода.
Если кто-то не против взглянуть на код, я с радостью отправлю его вам, чтобы проверить. Еще раз он находится на Java и довольно длинный.
Спасибо заранее.
Вот код. На стороне node Когда я очищаю смещения и клавиши, я использую int и long MAX_VALUE, поэтому, когда я сортирую, я знаю, что эти очищенные значения будут идти до конца node. Класс Split - это просто глупая идея, которую я ранее хотел исправить. Он состоит из node, смещения и ключа. Первоначально я думал, что мне может понадобиться вернуть смещение и ключ, который не был в расколе node. Затем я понял, что это было глупо, и все, что мне когда-либо понадобилось, было новым node.
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;
}
