/** Adiciona um novo elemento no começo da Lista Duplamente Encadeada.
 * Este método recebe um dado do tipo T e adiciona este elemento no começo da lista.
 * @param dado O dado que será inserido dentro da lista.
 * @see verificaMemoriaCheia();
 * @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.
 */
 virtual void adicionaNoInicioDuplo(const T& dado) {
     verificaMemoriaCheia();
     ElementoDuplo<T>* novo = new ElementoDuplo<T>(dado, head, NULL);
     head = novo;
     if (novo->getProximo() != NULL) {
         (novo->getProximo())->setAnterior(novo);
     }
     size++;
 }
Exemple #2
0
 /*!
 \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;
 }
Exemple #3
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);
 }
    /*
     * @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);
	    }
	}
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++;
}
Exemple #6
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 #7
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;
 }
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);
}
Exemple #9
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 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;
	    }
	}
    /*
     * @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 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());
            }
        }
	}
    /*
     * @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 #14
0
 /*!
 \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++;
 }
 /** Elimina um elemento no começo da Lista Duplamente Encadeada.
 * Este método elimina o primeiro elemento da Lista Duplamente Encadeada, ou seja, destrói o objeto sem retornar qualquer valor.
 * Chama o método "retiraDoInicio()" e caso este método retorne um objeto T, apaga esse objeto da memória.
 * @see retiraDoInicioDuplo()
 * @exception ExcecaoListaVazia Exceção que indica que o dado não pode ser eliminado pois a lista está vazia.
 */
 virtual void eliminaDoInicioDuplo() {
     if (!this->listaVazia()) {
         ElementoDuplo<T>* saiu = head;
         head = saiu->getProximo();
         size--;
         delete saiu;
     }
     throw ExcecaoListaVazia;
 }
Exemple #16
0
void ListaDupla<T>::eliminaDoInicioDuplo() {
	if (listaVazia()) {
		throw ExcecaoListaVazia();
	}
	ElementoDuplo<T>* saiu = cabeca;
	cabeca = saiu->getProximo();
	cabeca->setAnterior(0);
	tamanho--;
	delete saiu;
}
    /*
     * @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));
	        }
	    }
	}
Exemple #18
0
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();
}
Exemple #19
0
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();
}
 /** 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 #21
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 #22
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;
 }
Exemple #23
0
 /*!
 \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++;
 }
Exemple #24
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;
}
    /*
     * @brief Metodo para destruir toda a lista
     * @details Destroi a lista atraves de um laço de repetição, evitando assim "garbage" na memória
     * Cria dois ponteiros auxiliares: 'del' e 'atual'
     * Faz um laço deletando elemento por elemento e apos isso da set na cabeca como 'null' e tamanho recebe o valor '0'
     */
	void destroiListaDuplo() {
        ElementoDuplo<T> *del, *atual;
        atual = sentinela->getProximo();
        int i = 0;
        while (i != tamanho) {
            del = atual;
            atual = atual->getProximo();
            delete(del);
            i++;
        }
        tamanho = 0;
	}
 /** Método responsável por destruir a Lista Duplamente Encadeada.
 * Destrói a lista duplamente encadeada e desaloca todo o espaço de memória por ela ocupado.
 * @see listaVazia();
 */
 virtual void destroiListaDuplo() {
    ElementoDuplo<T> *atual;
     if (!listaVazia()) {
         while (head != NULL) {
             atual = head;
             head = atual->getProximo();
             delete atual;
         }
     } else {
         delete head;
     }
     size = 0;
 }
Exemple #27
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 #28
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;
}
 /** 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;
 }
 /** 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;
 }