/*!
* \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;
}
