/** Verifica a posição de memória de um dado já inserido na Lista.
* Este método recebe um dado que será analisado para verificar se este dado está dentro da Lista.
* @param dado O dado que será verificado a existência dentro da lista.
* @see listaVazia()
* @see igual(const T dado1, const T dado2)
* @exception ExcecaoListaVazia Exceção que indica que a lista está vazia, ou seja, não tem como esse dado existir dentro da Lista Duplamente Encadeada.
* @exception ExcecaoErroPosicao Exceção que indica que o dado do tipo T fornecido não está presente na lista.
* @return um ponteiro para T que indica a posição de memória em que o dado se encontrava.
*/
T* posicaoMemDuplo(const T& dado) const {
if (listaVazia()) {
throw ExcecaoListaVazia;
} else {
ElementoDuplo<T> *atual = head;
for (int i = 0; i < size; i++) {
if (igual(atual->getInfo(), dado)) {
return &atual->getInfo();
}
atual = atual->getProximo();
}
}
throw ExcecaoErroPosicao;
}
/*
* @brief Metodo posicaoMemDuplo
* @details Metodo para indicar a posição na memoria de determinado elemento
* @param O parametro 'dado' é o elemento especifico a ter sua posição encontrada na memoria
* É criado um ponteiro auxiliar chamado 'atual' e uma variavel do tipo T chamada 'dados'
* @return Retorna um ponteiro auxiliar que indica a aponta para 'dados'
*/
T* posicaoMemDuplo(const T& dado) const {
ElementoDuplo<T> *atual;
T dados;
if (listaVazia()) {
throw("Lista Vazia");
} else {
atual = atual->cabeca;
for (int i = 0; i < tamanho; i++) {
if (atual->getInfo() == dado) {
dados = atual->getInfo();
return &dados;
}
}
}
}
void ListaDupla<T>::adicionaEmOrdem(const T& data) {
if (listaVazia()) {
return adicionaNoInicioDuplo(data);
}
ElementoDuplo<T>* atual = cabeca;
int posicao = 1;
while (atual->getProximo() != 0 && maior(data, atual->getInfo())) {
atual = atual->getProximo();
posicao++;
}
if (maior(data, atual->getInfo())) {
return adicionaNaPosicaoDuplo(data, posicao + 1);
}
adicionaNaPosicaoDuplo(data, posicao);
}
/** Retorna um dado de determinada posição sem removê-lo da lista duplamente encadeada.
* @see verificaPosicaoInvalida(pos)
* @see listaVazia()
* @return Retorna o dado da posição informada - se ele existir, caso contrário retorna uma exceção.
*/
virtual T mostra(int pos) {
verificaPosicaoInvalida(pos);
if (listaVazia()) {
throw ExcecaoListaVazia;
} else {
ElementoDuplo<T> *atual = head;
if (pos == 0) {
return atual->getInfo();
}
for (int i = 0; i < pos; i++) {
atual = atual->getProximo();
}
return atual->getInfo();
}
}
T ListaDupla<T>::mostra(int pos) {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
ElementoDuplo<T>* mostra = cabeca;
for (int i = 0; i < tamanho - 1; i++) {
mostra = mostra->getProximo();
}
return mostra->getInfo();
}
/*
* @brief Metodo adicionaEmOrdem
* @details Metodo para adicionar elementos em uma determinada ordem na Lista
* @param O parametro 'data' é o elemento que sera adicionado na Lista
* É criado um ponteiro chamado 'atual' e uma variavel de inteiro 'pos' para auxiliar no funcionamento do metodo
*/
void adicionaEmOrdem(const T& data) {
ElementoDuplo<T> *atual;
int pos;
if (listaVazia()) {
return (adicionaNoInicioDuplo(data));
} else {
atual = sentinela->getProximo();
pos = 1;
while (atual->getProximo() != NULL && maior(data, atual->getInfo())) {
atual = atual->getProximo();
pos += 1;
}
if (maior(data, atual->getInfo())) {
(adicionaNaPosicaoDuplo(data, (pos+1)));
} else {
(adicionaNaPosicaoDuplo(data, pos-1));
}
}
}
T* ListaDupla<T>::posicaoMemDuplo(const T& dado) const {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
int posicao = posicaoDuplo(dado);
ElementoDuplo<T>* atual = cabeca;
for (int i = 1; i < posicao; i++) {
atual = atual->getProximo();
}
return atual->getInfo();
}
/*!
\param data um elemento a ser inserido em sequência na lista
\sa adicionaDuplo(), adicionaNoInicioDuplo(), adicionaNaPosicaoDuplo()
*/
void adicionaEmOrdem(const T& data) {
ElementoDuplo<T> *aux = head->getProximo();
if (listaVazia()) {
return adicionaNoInicioDuplo(data);
}
int pos = 1;
while (pos < size && maior(data, aux->getInfo())) {
aux = aux->getProximo();
pos++;
}
adicionaNaPosicaoDuplo(data, pos);
}
/** Adiciona um novo elemento ordenado de forma ascendente.
* 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(data);
* @see adicionaNaPosicaoDuplo(data, posicao);
*/
virtual void adicionaEmOrdem(const T& data) {
verificaMemoriaCheia();
ElementoDuplo<T>* atual;
int posicao;
if (listaVazia()) {
adicionaNoInicioDuplo(data);
} else {
atual = head;
posicao = 0;
while (atual->getProximo() != NULL &&
maior(data, atual->getInfo())) {
atual = atual->getProximo();
posicao++;
}
if (maior(data, atual->getInfo())) {
adicionaNaPosicaoDuplo(data, posicao + 1);
} else {
adicionaNaPosicaoDuplo(data, posicao);
}
}
}
/*!
\param pos a posição do elemento na lista
\return aux as informações do elemento contido na posição desejada
\sa verUltimo()
*/
T mostra(int pos) {
ElementoDuplo<T> *aux = head;
if (listaVazia()) {
throw "lista vazia";
}
int i;
while (i != pos) {
aux = aux->getProximo();
i++;
}
return aux->getInfo();
}
/*!
\param dado um elemento a ser verificado se está contido na lista
\return um valor boolean indicando se o dado está contido na lista
\sa posicaoDuplo(), posicaoMemDuplo()
*/
bool contemDuplo(const T& dado) {
ElementoDuplo<T> *aux = head->getProximo();
if (listaVazia()) {
throw "lista vazia";
}
for (int i = 0; i < size; i++) {
if (aux->getInfo() == dado) {
return true;
}
aux = aux->getProximo();
}
return false;
}
int ListaDupla<T>::posicaoDuplo(const T& dado) const {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
ElementoDuplo<T>* atual = cabeca;
for (int i = 0; i < tamanho; i++) {
if (dado == atual->getInfo()) {
return i;
}
atual = atual->getProximo();
}
throw ExcecaoDadoNaoEncontrado();
}
bool ListaDupla<T>::contemDuplo(const T& dado) {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
ElementoDuplo<T>* atual = cabeca;
for (int i = 0; i < tamanho; i++) {
if (igual(dado, atual->getInfo())) {
return true;
}
atual = atual->getProximo();
}
return false;
}
/*!
\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;
}
/*
* @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);
}
}
/*
* @brief Metodo contemDuplo
* @details Metodo indicar se um determinado dado está contido na Lista
* @param O parametro 'dado' é o elemento especifico a ser comparado com os outros presentes na lista
* É comparado o dado passado como parametro com todos os outros elementos da Lista
* @return Caso o um dado igual seja encontrado retorna 'True'
* @return Caso nem um dado igual seja encontrado retorna 'False'
*/
bool contemDuplo(const T& dado) {
if (listaVazia()) {
return (false);
} else {
ElementoDuplo<T> *auxiliar;
auxiliar = sentinela->getProximo();
for (int i = 0; i < tamanho; i++) {
if (auxiliar->getInfo() == dado) {
return (true);
}
auxiliar = auxiliar->getProximo();
}
return false;
}
}
/*!
\param dado um elemento a ser verificado sua posição na memória
\return aux um ponteiro auxiliar que aponta pro elemento verificado
\sa posicaoDuplo()
*/
T* posicaoMemDuplo(const T& dado) const {
ElementoDuplo<T> *aux = head->getProximo();
if (listaVazia()) {
throw "lista vazia";
}
int i = 0;
while (i < size && (aux->getInfo() != dado)) {
i++;
aux = aux->getProximo();
}
if (i >= size) {
throw "dado não existe";
}
return aux;
}
/*
* @brief Metodo mostra
* @details Metodo para mostra qual elemento está em determinada posição da lista
* @param O parametro 'pos' é a posição que pegaremos o dado a ser mostrado
* @return Retorna a informação do presente no dado da posição passada
*/
T mostra(int pos) {
if (listaVazia()) {
throw("ERROPOSICAO");
} else {
if (pos < 0 || pos > tamanho) {
throw("POSICAO INVALIDA");
} else {
ElementoDuplo<T> *aux = sentinela->getProximo();
for (int i = 0; i < pos; i++) {
aux = aux->getProximo();
}
return (aux->getInfo());
}
}
}
/** Retira um elemento no começo da Lista Duplamente Encadeada.
* Este método retira o primeiro elemento da Lista Duplamente Encadeada, retornando o objeto retirado.
* @see listaVazia()
* @exception ExcecaoListaVazia Exceção que indica que um dado não pode ser retirado da lista, pois ela está vazia.
* @return O elemento que estava no começo da lista caso esta não esteja vazia.
*/
virtual T retiraDoInicioDuplo() {
if (listaVazia()) {
throw ExcecaoListaVazia;
}
ElementoDuplo<T>* saiu;
T volta;
saiu = head;
volta = saiu->getInfo();
head = saiu->getProximo();
if (head != NULL) {
head->setAnterior(NULL);
}
size--;
delete saiu;
return volta;
}
/*
* @brief Metodo posicaoDuplo
* @details Metodo que indica a posição de um elemento contido na Lista
* @param O parametro 'dado' é o elemento a ter sua posição encontrada
* É criado uma variavel auxiliar de inteiros chamada 'contador'
* @return Retorna a variavel 'contador' que tem a posição do elemento dentro da Lista
*/
int posicaoDuplo(const T& dado) const {
int contador = 0;
if (listaVazia()) {
throw("Lista Vazia");
} else {
ElementoDuplo<T> *auxiliar = sentinela->getProximo();
while (contador < tamanho) {
if (dado == auxiliar->getInfo()) {
return (contador);
}
auxiliar = auxiliar->getProximo();
contador++;
}
throw("Elemento não existe");
}
}
T ListaDupla<T>::retiraDoInicioDuplo() {
ElementoDuplo<T>* saiu;
T volta;
if (listaVazia()) {
throw ExcecaoPosicao();
}
saiu = cabeca;
volta = saiu->getInfo();
cabeca = saiu->getProximo();
if (cabeca != 0) {
cabeca->setAnterior(0);
}
tamanho--;
delete saiu;
return volta;
}
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;
}
/*!
\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;
}
/** 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;
}