예제 #1
0
 /** 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++;
 }
예제 #2
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++;
 }
예제 #3
0
 /** 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;
 }
예제 #4
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();
}
예제 #5
0
void ListaDupla<T>::eliminaDoInicioDuplo() {
	if (listaVazia()) {
		throw ExcecaoListaVazia();
	}
	ElementoDuplo<T>* saiu = cabeca;
	cabeca = saiu->getProximo();
	cabeca->setAnterior(0);
	tamanho--;
	delete saiu;
}
예제 #6
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();
}
예제 #7
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;
 }
    /*
     * @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);
	    }
	}
예제 #9
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);
 }
예제 #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();
 }
예제 #11
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;
}
예제 #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();
}
예제 #13
0
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++;
}
예제 #14
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;
 }
예제 #15
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;
 }
예제 #16
0
 /** 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;
	            }
	        }
	    }
	}
예제 #18
0
 /** 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();
     }
 }
예제 #19
0
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);
}
    /*
     * @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());
            }
        }
	}
예제 #21
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 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");
	    }
	}
예제 #24
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;
}
예제 #25
0
 /** 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;
 }
예제 #26
0
 /** 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);
         }
     }
 }
    /*
     * @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;
	}
    /*
     * @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;
	        }
	    }
	}
예제 #29
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++;
 }
예제 #30
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;
 }