/** 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();
}
Exemple #8
0
 /*!
 \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);
         }
     }
 }
Exemple #10
0
 /*!
 \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();
 }
Exemple #11
0
 /*!
 \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;
 }
Exemple #12
0
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();
}
Exemple #13
0
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;
}
Exemple #14
0
 /*!
 \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;
	    }
	}
Exemple #17
0
 /*!
 \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");
	    }
	}
Exemple #21
0
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;
}
Exemple #22
0
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;
}
Exemple #23
0
 /*!
 \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;
 }