int bPlusTree::deleteNodehelper(int key, bPlusTreeNode *root)
{
int i;
int flag;
if (root == NULL)
return 0;
else
{
flag = searchnode(key, root, &i);
if (flag)
{
if (root->child[i - 1])
{
copysucc(root, i);
flag = deleteNodehelper(root->value[i], root->child[i]);
if (!flag)
cout << endl << "Value " << key << " not found.";
}
else
clear(root, i);
}
else
flag = deleteNodehelper(key, root->child[i]);
if (root->child[i] != NULL)
{
if (root->child[i]->count < MIN)
restore(root, i);
}
return flag;
}
}
//Check whether the key exists or not.
int bPlusTree::setkey(int val, bPlusTreeNode *n, int *p, bPlusTreeNode **ch)
{
int key;
if (n == NULL)
{
*p = val;
*ch = NULL;
return 1;
}
else
{
if (searchnode(val, n, &key))
cout << endl << "Key value already exists." << endl;
else if (setkey(val, n->child[key], p, ch))
{
if (n->count < MAX)
{
fillnode(*p, *ch, n, key);
return 0;
}
else
{
split(*p, *ch, n, key, p, ch);
return 1;
}
}
return 0;
}
}
int Btree ::setIpointer(int Ipointer, Node *node, int *point, Node **temp)
{
int pos ;
if ( node == NULL )
{
*point = Ipointer ;
*temp = NULL ;
return 1 ;
}
else
{
if ( searchnode ( Ipointer, node, &pos ) )
cout << "Ya existe" << endl ;
if ( setIpointer( Ipointer, node -> child[pos], point, temp) )
{
if ( node -> count < MAX )
{
fillnode ( *point, *temp, node, pos ) ;
return 0 ;
}
else
{
split ( *point, *temp, node, pos, point, temp ) ;
return 1 ;
}
}
return 0 ;
}
}
/**
* @brief Btree::eraseaux
* @param Ipointer
* @param root
* @return erase aux
*/
int Btree ::searchAux(int Ipointer, Node *root)
{
int i ;
int flag ;
if ( root == NULL )
return 0 ;
else
{
flag = searchnode ( Ipointer, root, &i ) ;
if ( flag )
{
if ( root -> child[i - 1] )
{
copy ( root, i ) ;
flag = searchAux ( root -> value[i], root -> child[i] ) ;
if ( !flag )
cout << endl << "Value " << Ipointer << " not found." ;
}
else
clear ( root, i ) ;
}
else
flag = searchAux( Ipointer, root -> child[i] ) ;
if ( root -> child[i] != NULL )
{
if ( root -> child[i] -> count < MIN )
restore ( root, i ) ;
}
return flag ;
}
}
void Tree::remove (Comparable *key) {
if (!root) return;
TreeNode *found = searchnode (key);
if (!found) return;
found->remove(found);
}
/**
* @brief Btree::search
* @param Ipointer
* @param root
* @param position
* @return
*search pointer in the tree
*/
Node * Btree ::search(int Ipointer, Node *root, int *position)
{
if ( root == NULL )
return NULL ;
else
{
if ( searchnode ( Ipointer, root, position ) )
return root ;
else
return search ( Ipointer, root -> child[*position], position ) ;
}
}
static int
dispatchsearch(int n, int *e, int nblue, int nred)
/* Multiple tries at solution */
{
int i,status;
addrval *valptr;
boolean ok;
nauty_counter remaininglimit;
ok = propagate(n,e,&nblue,&nred);
#if DEBUG
if (ok) dumpdata(0,nblue,nred,n);
else { printf("FAIL\n"); ++nphases[0]; return NO; }
#else
if (!ok) { ++nphases[0]; return NO; }
#endif
valptr = valstacktop;
remaininglimit = totallimit;
for (i = 0; i < NUMLIMITS; ++i)
{
if (totallimit > 0)
{
limit = locallimit[i];
if (limit == 0 || limit > remaininglimit) limit = remaininglimit;
remaininglimit -= limit;
if (limit == 0) limit = 1;
}
else
limit = locallimit[i];
nodes = 0;
status = searchnode(1,n,e,nblue,nred);
if (status != TIMEOUT)
{
++nphases[i+1];
return status;
}
while (valstacktop > valptr) UNSETVAL;
}
++ntimeouts;
return TIMEOUT;
}
/* XXX */
void
searchnode(
addr_t btree,
key_t key,
struct bt_entry **entry, /* output */
struct bt_node **node /* output */
)
{
int i;
addr_t addr;
struct bt_node *n = getnode(btree);
struct bt_entry *entries = n->entries;
for (i = 0; i < n->size; i++) {
struct bt_entry *e = &(entries[i]);
int cmp = compare(key, &(e->record));
if (cmp == 0) {
*entry = e;
*node = n;
return;
}
if (cmp > 0) break;
}
if (i == 0) {
addr = n->addr0;
} else {
addr = entries[i - 1].addr;
}
if (addr == ADDR_NULL) {
*entry = (struct bt_entry *) 0;
*node = n;
return;
}
freenode(n);
searchnode(addr, key, entry, node);
return;
}
record_t *
search(
BTREE* btree,
key_t key
)
{
struct bt_entry *entry;
struct bt_node *node;
record_t *ret;
searchnode(btree->root, key, &entry, &node);
if (entry) {
ret = (record_t *) malloc(sizeof (record_t));
*ret = entry->record; /* memcopy */
} else {
ret = (record_t *) 0;
}
freenode(node);
return ret;
}
// 8.0---------------------------------------------------------------------------------
int searchintree(int keyring, BTree* T){
if(T == NULL) return 0;
searchnode(keyring, T->root);
//printf("here8.2 \n");
return 0;
}
static int
searchnode(int level, int n, int *e, int nblue, int nred)
{
boolean ok;
int i,status,nbest;
addrval *valptr;
int best,score,bestscore;
int fe,fc;
long ran;
ok = propagate(n,e,&nblue,&nred);
#if DEBUG
if (ok) dumpdata(level,nblue,nred,n);
else { printf("FAIL\n"); return NO; }
#else
if (!ok) return NO;
#endif
if (nblue == n && nred == n) return YES;
#if FISHTAIL
status = fishtail(n,&nblue,&nred);
if (status == NO) return NO;
if (status == YES) return searchnode(level+1,n,e,nblue,nred);
#endif
valptr = valstacktop;
bestscore = -1;
nbest = 0;
for (i = 0; i < 2*n; ++i)
if (colour[i] == WHITE)
{
score = (bluedeg[v1[i]] == 1) + (bluedeg[v2[i]] == 1) +
(reddeg[v1[i]] == 1) + (reddeg[v2[i]] == 1);
if (score > bestscore)
{
bestscore = score;
beste[0] = i;
nbest = 1;
}
else if (score == bestscore)
beste[nbest++] = i;
}
if (bestscore == 0 && nred + nblue > 0)
return FALSE; /* Disconnected */
ran = KRAN(2*nbest);
best = beste[ran/2];
if ((ran&1))
{
if (makeblue(best,nblue==n-1))
{
#if DEBUG
printf(" setting %d(%d-%d) blue\n",best,v1[best],v2[best]);
#endif
status = searchnode(level+1,n,e,nblue+1,nred);
if (status != NO) return status;
while (valstacktop > valptr) UNSETVAL;
}
if (++nodes == limit) return TIMEOUT;
if (makered(best,nred==n-1))
{
#if DEBUG
printf(" setting %d(%d-%d) red\n",best,v1[best],v2[best]);
#endif
status = searchnode(level+1,n,e,nblue,nred+1);
if (status != NO) return status;
while (valstacktop > valptr) UNSETVAL;
}
}
else
{
if (makered(best,nred==n-1))
{
#if DEBUG
printf(" setting %d(%d-%d) red\n",best,v1[best],v2[best]);
#endif
status = searchnode(level+1,n,e,nblue,nred+1);
if (status != NO) return status;
while (valstacktop > valptr) UNSETVAL;
}
if (++nodes == limit) return TIMEOUT;
if (makeblue(best,nblue==n-1))
{
#if DEBUG
printf(" setting %d(%d-%d) blue\n",best,v1[best],v2[best]);
#endif
status = searchnode(level+1,n,e,nblue+1,nred);
if (status != NO) return status;
while (valstacktop > valptr) UNSETVAL;
}
}
return NO;
}
int voidexpr(ENODE *node)
{
CSE *csp;
if (node == 0)
return 0;
switch (node->nodetype)
{
case en_conslabel:
case en_destlabel:
case en_movebyref:
return voidexpr(node->v.p[0]);
case en_structret:
return 0;
case en_rcon:
case en_lrcon:
case en_fcon:
case en_rcomplexcon:
case en_lrcomplexcon:
case en_fcomplexcon:
case en_rimaginarycon:
case en_lrimaginarycon:
case en_fimaginarycon:
return 1;
case en_boolcon:
case en_icon:
case en_lcon:
case en_iucon:
case en_lucon:
case en_ccon:
case en_cucon:
case en_llcon:
case en_llucon:
case en_nacon:
case en_napccon:
case en_absacon:
case en_autocon:
case en_autoreg:
return 0;
case en_floatref:
case en_doubleref:
case en_longdoubleref:
case en_fimaginaryref:
case en_rimaginaryref:
case en_lrimaginaryref:
case en_fcomplexref:
case en_rcomplexref:
case en_lrcomplexref:
return 1;
case en_bool_ref:
case en_ub_ref:
case en_uw_ref:
case en_b_ref:
case en_w_ref:
case en_l_ref:
case en_ul_ref:
case en_ll_ref:
case en_ull_ref:
case en_fp_ref:
case en_i_ref:
case en_ui_ref:
case en_a_ref: case en_ua_ref:
return 0;
case en_uminus:
case en_bits:
case en_asuminus:
case en_ascompl:
case en_not:
case en_compl:
case en_cl_reg:
return voidexpr(node->v.p[0]);
case en_fcall:
case en_pfcall:
case en_pfcallb:
case en_sfcall:
case en_sfcallb:
case en_fcallb:
{
SYM *sp;
ENODE *node2 = node->v.p[1]->v.p[0]->v.p[0];
if (node2->nodetype == en_nacon || node2->nodetype ==
en_napccon)
{
sp = node2->v.sp;
if (sp && (sp->value.classdata.cppflags &PF_INLINE))
voidfloat(sp->value.classdata.inlinefunc->stmt);
}
}
case en_cfc:
case en_crc:
case en_clrc:
case en_cfi:
case en_cri:
case en_clri:
case en_cb:
case en_cub:
case en_cbool:
case en_cw:
case en_cuw:
case en_cl:
case en_cul:
case en_ci:
case en_cui:
case en_cll:
case en_cull:
case en_cf:
case en_cd:
case en_cp:
case en_cld:
case en_cfp:
case en_csp:
case en_thiscall:
case en_ainc:
case en_adec:
case en_add:
case en_sub:
case en_addstruc:
case en_addcast:
case en_umul:
case en_udiv:
case en_umod:
case en_mul:
case en_div:
case en_mod:
case en_lsh:
case en_asalsh:
case en_asarsh:
case en_alsh:
case en_arsh:
case en_arshd:
case en_asarshd:
case en_rsh:
case en_and:
case en_or:
case en_xor:
case en_land:
case en_lor:
case en_eq:
case en_ne:
case en_lt:
case en_le:
case en_ugt:
case en_uge:
case en_ult:
case en_ule:
case en_gt:
case en_ge:
case en_cond:
case en_void:
case en_voidnz:
case en_dvoid:
case en_pmul:
case en_arrayindex:
case en_moveblock:
case en_stackblock:
case en_intcall:
case en_pdiv:
case en_repcons:
case en_scallblock:
case en_callblock:
case en_pcallblock:
case en_array:
return voidexpr(node->v.p[0]) || voidexpr(node->v.p[1]);
case en_trapcall:
case en_substack:
case en_clearblock:
case en_loadstack:
case en_savestack:
return voidexpr(node->v.p[0]);
// return voidexpr(node->v.p[1]);
case en_asadd:
case en_assub:
case en_asmul:
case en_asdiv:
case en_asor:
case en_asand:
case en_asxor:
case en_asmod:
case en_aslsh:
case en_asumod:
case en_asudiv:
case en_asumul:
case en_asrsh:
case en_assign:
case en_refassign:
case en_lassign:
if (voidexpr(node->v.p[1]))
{
csp = searchnode(node->v.p[0]);
if (csp)
csp->voidf = 1;
}
return voidexpr(node->v.p[0]);
default:
return 0;
}
}
