Res SplayTreeDelete(SplayTree tree, SplayNode node, void *key) { SplayNode rightHalf, del, leftLast; Bool found; AVERT(SplayTree, tree); AVERT(SplayNode, node); found = SplaySplay(&del, tree, key, tree->compare); AVER(!found || del == node); if (!found) { return ResFAIL; } else if (SplayNodeLeftChild(node) == NULL) { SplayTreeSetRoot(tree, SplayNodeRightChild(node)); } else if (SplayNodeRightChild(node) == NULL) { SplayTreeSetRoot(tree, SplayNodeLeftChild(node)); } else { rightHalf = SplayNodeRightChild(node); SplayTreeSetRoot(tree, SplayNodeLeftChild(node)); if (SplaySplay(&leftLast, tree, key, tree->compare)) { return ResFAIL; } else { AVER(SplayNodeRightChild(leftLast) == NULL); SplayNodeSetRightChild(leftLast, rightHalf); if (tree->updateNode != NULL) { SplayNodeUpdate(tree, leftLast); } } } SplayNodeFinish(node); return ResOK; }
Bool SplayFindFirst(Tree *nodeReturn, SplayTree splay, SplayTestNodeFunction testNode, SplayTestTreeFunction testTree, void *closureP, Size closureS) { SplayFindClosureStruct closureStruct; Bool found; AVER(nodeReturn != NULL); AVERT(SplayTree, splay); AVER(FUNCHECK(testNode)); AVER(FUNCHECK(testTree)); if (SplayTreeIsEmpty(splay) || !testTree(splay, SplayTreeRoot(splay), closureP, closureS)) return FALSE; /* no suitable nodes in tree */ closureStruct.p = closureP; closureStruct.s = closureS; closureStruct.testNode = testNode; closureStruct.testTree = testTree; closureStruct.splay = splay; closureStruct.found = FALSE; found = SplaySplay(splay, &closureStruct, SplayFindFirstCompare) == CompareEQUAL && closureStruct.found; while (!found) { Tree oldRoot, newRoot; /* FIXME: Rename to "seen" and "not yet seen" or something. */ oldRoot = SplayTreeRoot(splay); newRoot = TreeRight(oldRoot); if (newRoot == TreeEMPTY || !(*testTree)(splay, newRoot, closureP, closureS)) return FALSE; /* no suitable nodes in the rest of the tree */ /* Temporarily chop off the left half-tree, inclusive of root, so that the search excludes any nodes we've seen already. */ SplayTreeSetRoot(splay, newRoot); TreeSetRight(oldRoot, TreeEMPTY); found = SplaySplay(splay, &closureStruct, SplayFindFirstCompare) == CompareEQUAL && closureStruct.found; /* Restore the left tree, then rotate left so that the node we just splayed is at the root. Update both. */ newRoot = SplayTreeRoot(splay); TreeSetRight(oldRoot, newRoot); SplayTreeSetRoot(splay, oldRoot); TreeRotateLeft(&splay->root); splay->updateNode(splay, oldRoot); splay->updateNode(splay, newRoot); } *nodeReturn = SplayTreeRoot(splay); return TRUE; }
Bool SplayFindLast(Tree *nodeReturn, SplayTree splay, SplayTestNodeFunction testNode, SplayTestTreeFunction testTree, void *testClosure) { SplayFindClosureStruct closureStruct; Bool found; AVER_CRITICAL(nodeReturn != NULL); AVERT_CRITICAL(SplayTree, splay); AVER_CRITICAL(FUNCHECK(testNode)); AVER_CRITICAL(FUNCHECK(testTree)); if (SplayTreeIsEmpty(splay) || !testTree(splay, SplayTreeRoot(splay), testClosure)) return FALSE; /* no suitable nodes in tree */ closureStruct.testClosure = testClosure; closureStruct.testNode = testNode; closureStruct.testTree = testTree; closureStruct.splay = splay; found = SplaySplay(splay, &closureStruct, SplayFindLastCompare) == CompareEQUAL && closureStruct.found; while (!found) { Tree oldRoot, newRoot; oldRoot = SplayTreeRoot(splay); newRoot = TreeLeft(oldRoot); if (newRoot == TreeEMPTY || !(*testTree)(splay, newRoot, testClosure)) return FALSE; /* no suitable nodes in the rest of the tree */ /* Temporarily chop off the right half-tree, inclusive of root, so that the search excludes any nodes we've seen already. */ SplayTreeSetRoot(splay, newRoot); TreeSetLeft(oldRoot, TreeEMPTY); found = SplaySplay(splay, &closureStruct, SplayFindLastCompare) == CompareEQUAL && closureStruct.found; /* Restore the right tree, then rotate right so that the node we just splayed is at the root. Update both. */ newRoot = SplayTreeRoot(splay); TreeSetLeft(oldRoot, newRoot); SplayTreeSetRoot(splay, oldRoot); TreeRotateRight(&splay->root); splay->updateNode(splay, oldRoot); splay->updateNode(splay, newRoot); } *nodeReturn = SplayTreeRoot(splay); return TRUE; }
static Tree SplayTreeSuccessor(SplayTree splay) { Tree oldRoot, newRoot; AVERT(SplayTree, splay); AVER(!SplayTreeIsEmpty(splay)); oldRoot = SplayTreeRoot(splay); if (!TreeHasRight(oldRoot)) return TreeEMPTY; /* No successor */ /* temporarily chop off the left half-tree, inclusive of root */ SplayTreeSetRoot(splay, TreeRight(oldRoot)); TreeSetRight(oldRoot, TreeEMPTY); (void)SplaySplay(splay, NULL, compareLess); newRoot = SplayTreeRoot(splay); AVER(newRoot != TreeEMPTY); AVER(TreeLeft(newRoot) == TreeEMPTY); TreeSetLeft(newRoot, oldRoot); splay->updateNode(splay, oldRoot); splay->updateNode(splay, newRoot); return newRoot; }
Bool SplayFindLast(SplayNode *nodeReturn, SplayTree tree, SplayTestNodeMethod testNode, SplayTestTreeMethod testTree, void *closureP, unsigned long closureS) { SplayNode node; SplayFindClosureStruct closureStruct; AVER(nodeReturn != NULL); AVERT(SplayTree, tree); AVER(FUNCHECK(testNode)); AVER(FUNCHECK(testTree)); node = SplayTreeRoot(tree); if (node == NULL || !(*testTree)(tree, node, closureP, closureS)) return FALSE; /* no suitable nodes in tree */ closureStruct.p = closureP; closureStruct.s = closureS; closureStruct.testNode = testNode; closureStruct.testTree = testTree; closureStruct.tree = tree; if (SplaySplay(&node, tree, (void *)&closureStruct, &SplayFindLastCompare)) { *nodeReturn = node; return TRUE; } else { return FALSE; } }
static SplayNode SplayTreeSuccessor(SplayTree tree, void *key) { SplayNode oldRoot, newRoot; AVERT(SplayTree, tree); oldRoot = SplayTreeRoot(tree); AVERT(SplayNode, oldRoot); if (SplayNodeRightChild(oldRoot) == NULL) { newRoot = NULL; /* No successor */ } else { /* temporarily chop off the left half-tree, inclusive of root */ SplayTreeSetRoot(tree, SplayNodeRightChild(oldRoot)); SplayNodeSetRightChild(oldRoot, NULL); if (SplaySplay(&newRoot, tree, key, tree->compare)) { NOTREACHED; /* Another matching node found */ } else { AVER(SplayNodeLeftChild(newRoot) == NULL); SplayNodeSetLeftChild(newRoot, oldRoot); } if (tree->updateNode != NULL) { SplayNodeUpdate(tree, oldRoot); SplayNodeUpdate(tree, newRoot); } } return newRoot; }
Bool SplayTreeDelete(SplayTree splay, Tree node) { Tree leftLast; Compare cmp; AVERT(SplayTree, splay); AVERT(Tree, node); if (SplayTreeIsEmpty(splay)) return FALSE; cmp = SplaySplay(splay, splay->nodeKey(node), splay->compare); AVER(cmp != CompareEQUAL || SplayTreeRoot(splay) == node); if (cmp != CompareEQUAL) { return FALSE; } else if (!TreeHasLeft(node)) { SplayTreeSetRoot(splay, TreeRight(node)); TreeClearRight(node); } else if (!TreeHasRight(node)) { SplayTreeSetRoot(splay, TreeLeft(node)); TreeClearLeft(node); } else { Tree rightHalf = TreeRight(node); TreeClearRight(node); SplayTreeSetRoot(splay, TreeLeft(node)); TreeClearLeft(node); (void)SplaySplay(splay, NULL, compareGreater); leftLast = SplayTreeRoot(splay); AVER(leftLast != TreeEMPTY); AVER(!TreeHasRight(leftLast)); TreeSetRight(leftLast, rightHalf); splay->updateNode(splay, leftLast); } TreeFinish(node); return TRUE; }
Bool SplayTreeFind(Tree *nodeReturn, SplayTree splay, TreeKey key) { AVERT(SplayTree, splay); AVER(nodeReturn != NULL); if (SplayTreeIsEmpty(splay)) return FALSE; if (SplaySplay(splay, key, splay->compare) != CompareEQUAL) return FALSE; *nodeReturn = SplayTreeRoot(splay); return TRUE; }
void SplayNodeRefresh(SplayTree splay, Tree node) { Compare cmp; AVERT(SplayTree, splay); AVERT(Tree, node); AVER(!SplayTreeIsEmpty(splay)); /* must contain node, at least */ cmp = SplaySplay(splay, splay->nodeKey(node), splay->compare); AVER(cmp == CompareEQUAL); AVER(SplayTreeRoot(splay) == node); splay->updateNode(splay, node); }
SplayNode SplayTreeNext(SplayTree tree, SplayNode oldNode, void *oldKey) { Bool b; SplayNode node; AVERT(SplayTree, tree); AVERT(SplayNode, oldNode); /* Make old node the root. Probably already is. */ b = SplaySplay(&node, tree, oldKey, tree->compare); AVER(b); AVER(node == oldNode); return SplayTreeSuccessor(tree, oldKey); }
SplayNode SplayTreeFirst(SplayTree tree, void *zeroKey) { SplayNode node; AVERT(SplayTree, tree); if (SplayTreeRoot(tree) == NULL) { node = NULL; } else if (SplaySplay(&node, tree, zeroKey, tree->compare)) { NOTREACHED; } else { AVER(SplayNodeLeftChild(node) == NULL); } return node; }
Res SplayTreeSearch(SplayNode *nodeReturn, SplayTree tree, void *key) { SplayNode node; AVERT(SplayTree, tree); AVER(nodeReturn != NULL); if (SplaySplay(&node, tree, key, tree->compare)) { *nodeReturn = node; } else { return ResFAIL; } return ResOK; }
void SplayNodeRefresh(SplayTree tree, SplayNode node, void *key) { Bool b; SplayNode node2; AVERT(SplayTree, tree); AVERT(SplayNode, node); b = SplaySplay(&node2, tree, key, tree->compare); AVER(b); AVER(node == node2); (*tree->updateNode)(tree, node, SplayNodeLeftChild(node), SplayNodeRightChild(node)); }
Tree SplayTreeFirst(SplayTree splay) { Tree node; AVERT(SplayTree, splay); if (SplayTreeIsEmpty(splay)) return TreeEMPTY; (void)SplaySplay(splay, NULL, compareLess); node = SplayTreeRoot(splay); AVER(node != TreeEMPTY); AVER(TreeLeft(node) == TreeEMPTY); return node; }
Res SplayTreeInsert(SplayTree tree, SplayNode node, void *key) { SplayNode neighbour; AVERT(SplayTree, tree); AVERT(SplayNode, node); AVER(SplayNodeLeftChild(node) == NULL); AVER(SplayNodeRightChild(node) == NULL); if (SplayTreeRoot(tree) == NULL) { SplayTreeSetRoot(tree, node); } else if (SplaySplay(&neighbour, tree, key, tree->compare)) { return ResFAIL; } else { AVER(SplayTreeRoot(tree) == neighbour); switch(SplayCompare(tree, key, neighbour)) { case CompareGREATER: { /* left neighbour */ SplayTreeSetRoot(tree, node); SplayNodeSetRightChild(node, SplayNodeRightChild(neighbour)); SplayNodeSetLeftChild(node, neighbour); SplayNodeSetRightChild(neighbour, NULL); } break; case CompareLESS: { /* right neighbour */ SplayTreeSetRoot(tree, node); SplayNodeSetLeftChild(node, SplayNodeLeftChild(neighbour)); SplayNodeSetRightChild(node, neighbour); SplayNodeSetLeftChild(neighbour, NULL); } break; case CompareEQUAL: default: { NOTREACHED; } break; } if (tree->updateNode != NULL) { SplayNodeUpdate(tree, neighbour); SplayNodeUpdate(tree, node); } } return ResOK; }
Bool SplayTreeInsert(SplayTree splay, Tree node) { Tree neighbour; AVERT(SplayTree, splay); AVERT(Tree, node); AVER(TreeLeft(node) == TreeEMPTY); AVER(TreeRight(node) == TreeEMPTY); if (SplayTreeIsEmpty(splay)) { SplayTreeSetRoot(splay, node); return TRUE; } switch (SplaySplay(splay, splay->nodeKey(node), splay->compare)) { default: NOTREACHED; /* fall through */ case CompareEQUAL: /* duplicate node */ return FALSE; case CompareGREATER: /* left neighbour is at root */ neighbour = SplayTreeRoot(splay); SplayTreeSetRoot(splay, node); TreeSetRight(node, TreeRight(neighbour)); TreeSetLeft(node, neighbour); TreeSetRight(neighbour, TreeEMPTY); break; case CompareLESS: /* right neighbour is at root */ neighbour = SplayTreeRoot(splay); SplayTreeSetRoot(splay, node); TreeSetLeft(node, TreeLeft(neighbour)); TreeSetRight(node, neighbour); TreeSetLeft(neighbour, TreeEMPTY); break; } splay->updateNode(splay, neighbour); splay->updateNode(splay, node); return TRUE; }
Tree SplayTreeNext(SplayTree splay, TreeKey oldKey) { AVERT(SplayTree, splay); if (SplayTreeIsEmpty(splay)) return TreeEMPTY; /* Make old node the root. Probably already is. We don't mind if the node has been deleted, or replaced by a node with the same key. */ switch (SplaySplay(splay, oldKey, splay->compare)) { default: NOTREACHED; /* defensive fall-through */ case CompareLESS: return SplayTreeRoot(splay); case CompareGREATER: case CompareEQUAL: return SplayTreeSuccessor(splay); } }
Res SplayTreeNeighbours(SplayNode *leftReturn, SplayNode *rightReturn, SplayTree tree, void *key) { SplayNode neighbour; AVERT(SplayTree, tree); AVER(leftReturn != NULL); AVER(rightReturn != NULL); if (SplaySplay(&neighbour, tree, key, tree->compare)) { return ResFAIL; } else if (neighbour == NULL) { *leftReturn = *rightReturn = NULL; } else { switch(SplayCompare(tree, key, neighbour)) { case CompareLESS: { *rightReturn = neighbour; *leftReturn = SplayTreePredecessor(tree, key); } break; case CompareGREATER: { *leftReturn = neighbour; *rightReturn = SplayTreeSuccessor(tree, key); } break; case CompareEQUAL: default: { NOTREACHED; } break; } } return ResOK; }