/******************************************************************************************
* deleteR()
*
* Arguments: h: ponteiro para um no da arvore
* k: key a procurar na arvore
*
* Returns: link
* Description: apaga um no correspondente a key dada
*****************************************************************************************/
link deleteR(link h, Key k) {
if (h==NULL)
return h;
else if (less(k, key(h->item)))
h->l = deleteR(h->l, k);
else if (less(key(h->item), k))
h->r = deleteR(h->r, k);
else {
if (h->l != NULL && h->r != NULL){
link aux = max(h->l);
Item x;
x = h->item;
h->item = aux->item;
aux->item = x;
h->l = deleteR(h->l, key(aux->item));
} else {
link aux = h;
if (h->l == NULL && h->r == NULL)
h = NULL;
else if (h->l == NULL)
h = h->r;
else
h = h->l;
deleteItem(aux->item);
free(aux);
}
}
h = AVLbalance(h);
return h;
}
/******************************************************************************************
* freeR()
*
* Arguments: h: ponteiro para um no da arvore
*
* Returns: void
* Description: liberta a memoria alocada para os nos da arvore
*****************************************************************************************/
link freeR(link h){
if (h == NULL)
return h;
h->l = freeR(h->l);
h->r = freeR(h->r);
return deleteR(h, key(h->item));
}
void deleteR(link t, Key v, int k)
{
if (t->next[k] == NULL) {
if (k > 0) {
deleteR(t, v, k-1);
return;
}
}
else if (eq(v, key(t->next[k]->item))){
t->next[k] = t->next[k]->next[k];
deleteR(t, v, k-1);
return;
}
else if (less(v, key(t->next[k]->item))){
if (k > 0) deleteR(t, v, k-1);
}
else deleteR(t->next[k], v, k);
}
link deleteR(link h, Key v) {
Key t = key(h->item);
if (less(v,t)) {
if (!hl->red && !hll->red) h = mvRedL(h);
hl = deleteR(hl, v);
}
else {
if (hl->red) h = rotR(h);
if (eq(v,key(h->item)) && hr == z)
free(h); return z;
if (!hr->red && !hrl->red) h = mvRedR(h);
if (eq(v,key(h->item))) {
h->item = getMin(hr);
hr = deleteMin(hr);
}
else hr = deleteR(hr, v);
}
return balance(h);
}
void readInput() {
NodeList NList;
cout << "> ";
cout.flush();
string line, command;
getline (cin, line); // Get a line from standard input
while (!cin.eof()) {
// Put the line in a stringstream for parsing
// Making a new stringstream for each line so flags etc. are in a known state
stringstream lineStream (line);
lineStream >> command;
//call function depending on command
if(command == "insertR") insertR(lineStream, NList);
else if (command == "setV") setV(lineStream, NList);
else if (command == "unsetV") unsetV(lineStream, NList);
else if (command == "solve") solve(lineStream, NList);
else if (command == "modifyR") modifyR(lineStream, NList);
else if (command == "printR") printR(lineStream, NList);
else if (command == "printNode") printNode(lineStream, NList);
else if (command == "deleteR") deleteR(lineStream, NList);
else if (command == "draw") draw(NList);
else cout << "Error: invalid command" << endl;
command = " ";
cout << "> ";
cout.flush();
getline (cin, line);
} // End input loop until EOF.
return;
}
/******************************************************************************************
* AVLapaga()
*
* Arguments: head: ponteiro para ponteiro para a cabeca da arvore AVL
* k: key a procurar na arvore
*
* Returns: void
* Description: chama a funcao que apaga o no correspondente a key recebida da arvore
*****************************************************************************************/
void AVLapaga(link *head, Key k){
*head = deleteR(*head, k);
}
void STdelete(Key v)
{
deleteR(head, v, lgN); N--;
}
void STdelete(link head, Key v) {
if (!head->l->red && !head->r->red) head->red = 1;
head = deleteR(head, v);
if (STcount(head) > 0) head->red = 0;
}
