int recInsert(Element *e, Hash *h , Hash* newHash, int size)
{
int code = e->prefix;
if(size>=newHash->size/2)
return -1;
if((code = findInHash(newHash, e->prefix, e->ch)) != EMPTY)
return code;
if(e->prefix != EMPTY)
{
Element *temp = h->shadowArray[e->prefix];
if ((code = recInsert(temp , h, newHash, size+1)) ==-1)
return -1;
}
return insert(newHash, code, e->ch, e->time);
}
void prune(int *args, Hash **hashTable, unsigned int time)
{
Hash *h = *hashTable;
Hash *newHash = malloc(sizeof(Hash));
initialize(newHash, 1 << (args[1]+1), 1, time);
int i=4;
if (!args[3])
for(i=4;i<260; i++)
insert(newHash, EMPTY, (char)(i-4), h->shadowArray[i]->time);
for(;i<h->numElements; i++)
if((time - h->shadowArray[i]->time) <= args[2])
recInsert(h->shadowArray[i], h, newHash, newHash->numElements+1);
freeHash(h);
*hashTable = newHash;
}
void insert(RTree *t, nodeVal *val){
insertVal *ret;
node *n1, *n2, *n;
nodeVal *cpval = new(nodeVal);
cpval->r = dupRect(val->r);
cpval->child = val->child;
val = cpval;
if(t->root == NULL){
n = makeNode(TRUE);
n->values[n->size++] = val;
n->MBR = dupRect(val->r);
writeNode(n);
t->root = n;
}
else{
ret = recInsert(t->root, val);
n1 = ret->node1;
n2 = ret->node2;
free(ret);
if(n2 != NULL){
n = makeNode(FALSE);
n->values[n->size++] = makeNodeVal(dupRect(n1->MBR), n1->address);
n->values[n->size++] = makeNodeVal(dupRect(n2->MBR), n2->address);
n->MBR = dupRect(n1->MBR);
increaseMBR(n->MBR, n2->MBR);
writeNode(n);
t->root = n;
freeNode(n1);
freeNode(n2);
}
}
}
insertVal *recInsert(node *n, nodeVal *val){
rect *r;
node *n1, *n2;
insertVal *ret;
if(n->leaf){
freeNodeVal(n->values[n->size]);
n->values[n->size++] = val;
//Si no hay overflow. *n->size aumento*
if(n->size <= 2*b){
increaseMBR(n->MBR, val->r);
writeNode(n);
ret = new(insertVal);
ret->node1 = n;
ret->node2 = NULL;
}
else{
ret = split(n, TRUE);
}
return ret;
}
else{
int imin = -1;
float min = HUGE_VAL, amin,mbr;
int i;
for(i = 0; i < n->size; i++){
r = n->values[i]->r;
mbr = deltaMBR(r, val->r);
if(mbr < min){
min = mbr, imin = i;
amin = area(r) + mbr;
}
else if(mbr == min && (area(r)+mbr)<amin){
imin=i;
amin = area(r)+mbr;
}
}
increaseMBR(n->MBR, val->r);
ret = recInsert(readNode(n->values[imin]->child), val);
n1 = ret->node1;
n2 = ret->node2;
free(ret);
//Colgar primer nodo.
freeNodeVal(n->values[imin]);
n->values[imin] = makeNodeVal(dupRect(n1->MBR), n1->address);
//Si hubo overflow en el hijo colgamos segundo nodo.
if(n2 != NULL){
freeNodeVal(n->values[n->size]);
n->values[n->size++] = makeNodeVal(dupRect(n2->MBR), n2->address);
}
//Si no hubo overflow en el hijo o no hay overflow aquí.
if(n2 == NULL || n->size <= 2*b){
writeNode(n);
ret = new(insertVal);
ret->node1 = n;
ret->node2 = NULL;
}
else
ret = split(n, FALSE);
freeNode(n1);
freeNode(n2);
return ret;
}
}
