Ejemplo n.º 1
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++;
 }
    /*
     * @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;
	        }
	    }
	}
Ejemplo n.º 3
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);
	    }
	}
Ejemplo n.º 5
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++;
 }
Ejemplo n.º 6
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++;
}
Ejemplo n.º 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;
 }
Ejemplo n.º 8
0
 /** 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);
        }
	}
Ejemplo n.º 10
0
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++;
}
Ejemplo n.º 11
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;
 }
Ejemplo n.º 12
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;
}
Ejemplo n.º 13
0
 /** 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;
 }
Ejemplo n.º 14
0
    /*!
    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);
    }