/*!
\param dado um elemento a ser adicionado no inicio da lista
\sa adicionaDuplo(), adicionaEmOrdemDuplo(), adicionaNaPosicaoDuplo()
*/
void adicionaNoInicioDuplo(const T& dado) {
ElementoDuplo<T> *aux = new ElementoDuplo<T>(dado, head->getProximo(),
head);
if (aux == NULL) {
throw "elemento não alocado";
}
head->setProximo(aux);
size++;
}
/*
* @brief Metodo adicionaNoInicio
* @details Metodo para adicionar um elemento no inicio da Lista
* @param O parametro 'dado' é o elemento a ser adicionado no inicio da Lista
* É Criado um ponteiro chamado 'novo' e é passado como parametro desse panteiro 'dado' e 'cabeca'
*/
void adicionaNoInicioDuplo(const T& dado) {
ElementoDuplo<T> *novo = new ElementoDuplo<T>(dado, nullptr, nullptr);
if (novo == NULL) {
throw("Lista Cheia");
} else {
if (tamanho == 0) {
novo->setProximo(sentinela);
novo->setAnterior(sentinela);
sentinela->setProximo(novo);
sentinela->setAnterior(novo);
tamanho += 1;
} else {
novo->setProximo(sentinela->getProximo());
novo->setAnterior(sentinela);
sentinela->setProximo(novo);
tamanho += 1;
}
}
}
/*!
\sa retiraDoInicioDuplo(), retiraDuplo(), retiraDaPosicaoDuplo(),
retiraEspecificoDuplo()
*/
void eliminaDoInicioDuplo() {
ElementoDuplo<T> *aux;
if (listaVazia()) {
throw "lista vazia";
}
aux = head;
head = aux->getProximo();
head->setProximo(aux->getProximo());
size--;
delete aux;
}
/*
* @brief Metodo eliminaDoInicioDuplo
* @details Metodo para eliminar um elemento do inicio da Lista e libera o endereço de memória que estava sendo usado pelo elemento
* Cria um ponteiro auxiliar chamado 'saiu'
*/
void eliminaDoInicioDuplo() {
ElementoDuplo<T> *saiu;
if (listaVazia()) {
throw("Erro Lista Vazia");
} else {
saiu = sentinela->getProximo();
sentinela->setProximo(saiu->getProximo());
saiu->getProximo()->setAnterior(sentinela);
tamanho -= 1;
delete(saiu);
}
}
/*!
\param dado um elemento a ser inserido
\param pos a posicao onde o dado vai ser inserido
\sa adicionaDuplo(), adicionaNoInicioDuplo(), adicionaEmOrdemDuplo()
*/
void adicionaNaPosicaoDuplo(const T& dado, int pos) {
ElementoDuplo<T> *novo = new ElementoDuplo<T> (dado, head, NULL);
ElementoDuplo<T> *anterior = head->getProximo();
if (novo == NULL) {
throw "posição inválida";
}
if (pos > size-1 || pos < 0) {
throw "posição inválida";
}
if (pos == 0) {
return adicionaNoInicioDuplo(dado);
}
for (int i = 0; i < pos-1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
novo->getProximo()->setAnterior(novo);
anterior->setProximo(novo);
novo->setAnterior(anterior);
size++;
}
void ListaDupla<T>::adicionaNoInicioDuplo(const T& dado) {
ElementoDuplo<T>* novo = new ElementoDuplo<T>(dado, 0, 0);
if (novo == 0) {
throw ExcecaoListaCheia();
}
novo->setProximo(cabeca);
novo->setAnterior(0);
cabeca = novo;
if (novo->getProximo() != 0) {
novo->getProximo()->setAnterior(novo);
}
tamanho++;
}
/*!
\return dado as informações contidas no elemento removido da lista
\sa eliminaDoInicioDuplo(), retiraDuplo(), retiraDaPosicaoDuplo(),
retiraEspecificoDuplo()
*/
T retiraDoInicioDuplo() {
ElementoDuplo<T> *aux;
T dado;
if (listaVazia()) {
throw "lista vazia";
}
aux = head->getProximo();
dado = aux->getInfo();
head->setProximo(aux->getProximo());
head->getProximo()->setAnterior(head);
size--;
delete aux;
return dado;
}
/** Adiciona um novo elemento na posição dada.
* Este método recebe um dado do tipo T e adiciona este elemento na posição "pos".
* @param dado O dado que será inserido dentro da lista.
* @param pos A posição em que o dado será adicionado.
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois não há mais espaço em memória.
* @exception ExcecaoErroPosicao A posição dada excedeu o tamanho dessa estrutura, ou seja, foi maior do que "size + 1".
* @see verificaMemoriaCheia();
* @see adicionaNoInicioDuplo(dado);
*/
virtual void adicionaNaPosicaoDuplo(const T& dado, int pos) {
verificaMemoriaCheia();
ElementoDuplo<T>* novo = new ElementoDuplo<T>(dado, NULL, NULL);
ElementoDuplo<T>* anterior;
if (pos > size || pos < 0) {
throw ExcecaoErroPosicao;
}
if (pos == 0) {
adicionaNoInicioDuplo(dado);
} else {
anterior = head;
for (int i = 0; i < pos - 1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
if (novo->getProximo() != NULL) {
(novo->getProximo())->setAnterior(novo);
}
novo->setAnterior(anterior);
anterior->setProximo(novo);
size++;
}
}
/*
* @brief Metodo retiraDoInicioDuplo
* @details Metodo para retirar um elemento do inicio da Lista e libera o endereço de memória que estava sendo usado pelo elemento
* Cria um ponteiro auxiliar chamado 'saiu'
* Cria uma varaivel auxiliar chamada 'volta'
* @return Retorna o elemento retirado que esta contido na varaivel 'volta'
*/
T retiraDoInicioDuplo() {
ElementoDuplo<T> *saiu;
T volta;
if (listaVazia()) {
throw("Lista vazia");
} else {
saiu = sentinela->getProximo();
volta = saiu->getInfo();
sentinela->setProximo(saiu->getProximo());
saiu->getProximo()->setAnterior(sentinela);
tamanho -= 1;
delete (saiu);
return (volta);
}
}
void ListaDupla<T>::adicionaNaPosicaoDuplo(const T& dado, int pos) {
if (posicaoInvalida(pos)) {
throw ExcecaoPosicao();
}
if (pos == 0) {
adicionaNoInicioDuplo(dado);
return;
}
ElementoDuplo<T>* anterior = cabeca;
ElementoDuplo<T>* novo = new ElementoDuplo<T>(dado, 0, 0);
if (novo == 0) {
throw ExcecaoListaCheia();
}
for (int i = 0; i < pos - 1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
if(novo->getProximo() != 0) {
novo->getProximo()->setAnterior(novo);
}
anterior->setProximo(novo);
anterior->getProximo()->setAnterior(anterior);
tamanho++;
}
/*!
\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;
}
/** 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;
}
/*!
Construtor da classe ListaDuplaCirc. A lista é criada vazia, iniciada
com tamanho "0" e a cabeça vazia
*/
ListaDuplaCirc() {
size = 1;
head = new ElementoDuplo<T>(0, 0, 0);
head->setProximo(head);
head->setAnterior(head);
}
