/*! * \brief Funcao retiraDaPosicaoDuplo * \param posicao e um inteiro que indica a posicao em que deve-se * tentar retirar o dado. * \return o tipo generico que representa o dado retirado da lista, o * que foi salvo temporariamente durante o processo. * \sa retiraDoInicioDuplo() * * Se a posicao for valida e ser a zero, chama a funcao * retiraDoInicioDuplo para realizar o processo de remocao do * dado. Se a posicao nao for a zero, entao caminha ate o vertice * anterior ao da posicao em que se pretende deletar com outro * elemento temporario. Ao chegar nessa posicao, salva * temporariamente o dado e o vertice que serao deletados, aponta * o vertice, anterior ao nodo que sera deletado, para o vertice * seguinte, ao que sera deletado. Se o proximo vertice existir, * ou seja, for diferente de um nullptr, entao aponta o anterior * dele para o vertice anterior ao da posicao que sera deletada. * Por fim, diminui o numero que indica o tamanho da lista e * deleta o vertice. */ T retiraDaPosicaoDuplo(int pos) { if (pos >= size) { throw "problema"; } else { if (pos == 0) { return retiraDoInicioDuplo(); } else { Elemento<T> *antElemento, *tmpElemento; T tmpInfo; antElemento = head; while (--pos != 0) antElemento = antElemento->getProximo(); tmpElemento = antElemento->getProximo(); tmpInfo = tmpElemento->getInfo(); antElemento->setProximo(tmpElemento->getProximo()); if (tmpElemento->getProximo() != nullptr) tmpElemento->getProximo()->setBack(antElemento); size -= 1; delete tmpElemento; return tmpInfo; } } }
T retiraDaPosicaoDuplo(int pos) { //verificar size >= Elemento2<T> *anterior, *eliminar; T retorno; if (pos >= size || pos < 0) { throw 20; } if (pos == 0) { return retiraDoInicioDuplo(); } anterior = head; for (int i = 0; i < pos - 1; i++) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); retorno = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); if (eliminar->getProximo() != NULL) { eliminar->getProximo()->setAnterior(anterior); } size--; delete eliminar; return retorno; }
/** * @brief Retira um elemento de uma posição deseja e retorna seu dado * * @param Posição do elemento a ser retirado * * @details Caso a posição seja 0, chama o metódo retiraDoInicioDuplo(), pois * é um caso específico */ T retiraDaPosicaoDuplo(int pos) { if(listaVazia()) { throw std::runtime_error("Lista Vazia"); } if(pos > size-1 || pos < 0) { throw std::runtime_error("Posição Inválida"); } else { if(pos == 0) { return retiraDoInicioDuplo(); } else { ElementoDuplaEnc<T> *anterior = head; ElementoDuplaEnc<T> *eliminar; for(int i = 0; i < (pos-1); i++) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); T volta = eliminar->getInfo(); eliminar->getProximo()->setAnterior(anterior); anterior->setProximo(eliminar->getProximo()); delete eliminar; --size; return volta; } } }
/*! \param pos um inteiro indicando a posição do elemento a ser retirado \return dado as informações do elemento retirado da lista \sa retiraDuplo(), retiraDoInicioDuplo(),eliminaDoInicioDuplo(), retiraEspecificoDuplo() */ T retiraDaPosicaoDuplo(int pos) { ElementoDuplo<T> *elementoRetirado; ElementoDuplo<T> *aux = head->getProximo(); T dado; if (pos > size-1 || pos < 0) { throw "posicao invalida"; } if (pos == 0) { retiraDoInicioDuplo(); } for (int i = 0; i < pos-1; i++) { aux = aux->getProximo(); } elementoRetirado = aux->getProximo(); dado = elementoRetirado->getInfo(); aux->setProximo(elementoRetirado->getProximo()); elementoRetirado->getProximo()->setAnterior(aux); size--; delete elementoRetirado; return dado; }
T ListaDupla<T>::retiraDaPosicaoDuplo(int pos) { if (posicaoInvalida(pos)) { throw ExcecaoPosicao(); } if (pos == 0) { return retiraDoInicioDuplo(); } ElementoDuplo<T>* anterior = cabeca; for (int i = 0; i < pos - 2; i++) { anterior = anterior->getProximo(); } ElementoDuplo<T>* eliminar = anterior->getProximo(); T volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); if (eliminar->getProximo() != 0) { eliminar->getProximo()->setAnterior(anterior); } tamanho--; delete eliminar; return volta; }
/* * @brief Metodo retiraDaPosicaoDuplo * @details Metodo para retirar um elemento de uma posicao especifica da Lista * @param O parametro 'pos' é a posição especifica do elemento a ser retirado da lista * É Criado dois ponteiros auxiliares para retirar o dado da lista que são: 'anterior' e 'eliminar' * É também é criada uma variavel do tipo T chamada 'volta' * @return Caso a posição seja igual a '0' retorna o metodo 'retiraDoInicio' * @return Caso seja qualquer outra posição valida é retornada a variavel 'volta' */ T retiraDaPosicaoDuplo(int pos) { ElementoDuplo<T> *anterior, *eliminar; T volta; if (pos >= tamanho || pos < 0) { throw("Nao da"); } else { if (pos == 0) { return (retiraDoInicioDuplo()); } else { anterior = sentinela->getProximo(); for (int i = 0; i < pos-1; i++) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); eliminar->getProximo()->setAnterior(anterior); tamanho -=1; delete(eliminar); } return(volta); } }
/** Retira um elemento de dentro da lista de acordo com a posição dada. * Este método recebe um inteiro que indica a posição de um dado que se deseja retirar da Lista Duplamente Encadeada. * @param pos A posição do dado que se deseja retirar. * @see retiraDoInicioDuplo() * @see retornaAnterior(int pos) * @exception ExcecaoErroPosicao Exceção que indica que a posição dada é invalida. * @return um objeto T que foi retirado da posição especificada. */ virtual T retiraDaPosicaoDuplo(int pos) { if (pos > size || pos < 0) { throw ExcecaoErroPosicao; } if (pos == 0) { return retiraDoInicioDuplo(); } ElementoDuplo<T>* eliminar; ElementoDuplo<T>* anterior = head; T volta; for (int i = 0; i < pos - 1; i++) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); if (eliminar->getProximo() != NULL) { (eliminar->getProximo())->setAnterior(anterior); } size--; delete eliminar; return volta; }