int get_successors(char *key, int k, char *result[]) {
if (k<1) {
printf("k should be positive not -1");
return -1;
}
int i, j, len=0;
PAGENO PageNo = treesearch_page(ROOT, key);
assert(PageNo > 0);
struct PageHdr *PagePtr = FetchPage(PageNo);
struct KeyRecord *KeyRcPtr = PagePtr->KeyListPtr;
if (result == NULL) {
result = (char **)malloc(sizeof(char) * 10 * k);
for (i=0; i<k; i++)
result[i] = (char *)malloc(sizeof(char) * 10);
}
while (strcmp(key, KeyRcPtr->StoredKey)>0) {
KeyRcPtr = KeyRcPtr->Next;
}
if (strcmp(key, KeyRcPtr->StoredKey)==0)
KeyRcPtr = KeyRcPtr->Next;
for (i=0; i<k && PagePtr!=NULL; i++) {
if (KeyRcPtr == NULL) {
PagePtr = FetchPage(PagePtr->PgNumOfNxtLfPg);
if (PagePtr == NULL)
break;
KeyRcPtr = PagePtr->KeyListPtr;
}
result[i] = (char *)KeyRcPtr->StoredKey;
KeyRcPtr = KeyRcPtr->Next;
len++;
}
/* sort the result array */
for (i=0; i<len; i++) {
for (j = i+1; j<len; j++) {
if (CompareKeys(result[i], result[j])==2) {
char *tmp = result[i];
result[i] = result[j];
result[j] = tmp;
}
}
}
printf("found %d successors:\n", len);
for (i=0; len>0; len--, i++) {
printf("%s\n",result[i]);
}
free(result);
return 0;
}
/**
* find the posting pointer to which the key should reside, given the
* starting page number to look at.
*
* to search the whole tree, pass in ROOT as the page number.
*/
POSTINGSPTR treesearch(PAGENO PageNo, char *key) {
/* recursive call to find page number */
const PAGENO page = treesearch_page(PageNo, key);
/* from page number we traverse the leaf page */
struct PageHdr *PagePtr = FetchPage(page);
POSTINGSPTR result = searchLeaf(PagePtr, key, 1);
FreePage(PagePtr);
return result;
}
/**
* recursive call to find the page in which the key should reside
* and return the page number (guaranteed to be a leaf page).
*/
PAGENO treesearch_page(PAGENO PageNo, char *key) { // ROOT, word
PAGENO result;
struct PageHdr *PagePtr = FetchPage(PageNo);
/*if (PagePtr != NULL) {
printf("\ntree search - pgnum:%ld", PagePtr->PgNum);
}*/
if (IsLeaf(PagePtr)) { /* found leaf */
result = PageNo;
} else if ((IsNonLeaf(PagePtr)) && (PagePtr->NumKeys == 0)) {
/* keys, if any, will be stored in Page# 2
THESE PIECE OF CODE SHOULD GO soon! **/
result = treesearch_page(FIRSTLEAFPG, key);
} else if ((IsNonLeaf(PagePtr)) && (PagePtr->NumKeys > 0)) {
PAGENO ChildPage = FindPageNumOfChild(PagePtr, PagePtr->KeyListPtr, key,
PagePtr->NumKeys);
result = treesearch_page(ChildPage, key);
} else {
assert(0 && "this should never happen");
}
FreePage(PagePtr);
return result;
}
int get_successors(char *key, int k, char *result[]) {
struct KeyRecord *KeyListTraverser;
int i;
PAGENO pg = treesearch_page(ROOT, key);
// fetch the first page
struct PageHdr *PagePtr = FetchPage(pg);
btReadCount ++;
// get the key list
KeyListTraverser = PagePtr->KeyListPtr;
//find the key in keylist, store the pointer
while(KeyListTraverser != NULL) {
if (strcmp(KeyListTraverser->StoredKey, key) == 0)
{
KeyListTraverser = KeyListTraverser->Next;
break;
}
else if (strcmp(KeyListTraverser->StoredKey, key) > 0)
{
break;
}
KeyListTraverser = KeyListTraverser->Next;
}
// then iterate each page and keyList to print the keys
int count = 0;
while(count < k) {
while(KeyListTraverser != NULL && count < k) {
strcpy(result[count], KeyListTraverser->StoredKey);
//result[count] = KeyListTraverser->StoredKey;
//printKey(KeyListTraverser);
count ++;
KeyListTraverser = KeyListTraverser->Next;
}
if (count < k && PagePtr->PgNumOfNxtLfPg != NULLPAGENO)
{
FreePage(PagePtr);
btReadCount++;
PagePtr = FetchPage(PagePtr->PgNumOfNxtLfPg);
//printf("the number of keys in this node: %d\n", PagePtr->NumKeys);
KeyListTraverser = PagePtr->KeyListPtr;
}
}
printf("found %d successors:\n", count);
for (i = 0; i < count; ++i)
{
printf("%s\n", result[i]);
}
FreePage(PagePtr);
return 0;
}
