Beispiel #1
0
	/**
	 * @brief      Adiciona dado de forma que a lista fique ordenada
	 *
	 * @param[in]  dado  Dado a ser adicionado
	 */
	void adicionaEmOrdem(const T& dado) {
		if (listaVazia()) return adicionaNoInicio(dado);
		auto current = head;
		auto old = current;
		int i = 0;
		while (current) {
			if (current->getInfo() > dado) break;
			old = current;
			current = current->getProximo();
			++i;
		}
		if (!i) return adicionaNoInicio(dado);
		if (i == size) return adiciona(dado);
		old->setProximo(std::make_shared<Elemento<T>>(dado, current));
		++size;
	}
Beispiel #2
0
/**
 * Método que adiciona um objeto da classe ElementoDeLista.
 *
 * Para isso verifica se ha espaço na mesma. Caso a questão anterior seja verdadeira o objeto é adicionado na posição recebida pelo parametro.
 *
 * @param InfoLista *dado= ponteiro para um objeto da classe InfoLista.
 * @param posicao = inteiro que identifica a posição em que o dado vai ser inserido.
 *
 * @return LISTA_CHEIA = caso a lista em execução já possua o numero de elementos determinado pela variável MAXLISTA.
 * @return ERRO_POSICAO = caso a posição informada seja inválida, ou seja, caso nao esteja entre o inicio e o final da lista.
 * @return tamanho = tamanho final da lista.
 */
int CabecaDeLista::adicionaNaPosicao(InfoLista *dado, int posicao) {
	ElementoDeLista *novo, *anterior;
	if (posicao > tamanho + 1) {
		return ERRO_POSICAO;
	} else {
		if (posicao == 1) {
			return adicionaNoInicio(dado);
		} else {
			novo = new ElementoDeLista();
			if (novo == 0) {
				return LISTA_CHEIA;
			} else {
				anterior = primeiro;
				for (int i = 0; i < posicao - 2; i++) {
					anterior = anterior->proximo;
				}
				novo->proximo = anterior->proximo;
				novo->info = dado;
				anterior->proximo = novo;
				tamanho++;
				return tamanho;
			}
		}
	}
}
//fim
void ListaElementosGeometricos::adiciona(const ElementoGeometrico*& dado){
	if (size == 0)
		adicionaNoInicio(dado);
	else
		adicionaNaPosicao(dado,size-1);
	
}
Beispiel #4
0
	/**
	 * @brief      Adiciona o dado no final da lista
	 *
	 * @param[in]  dado   Dado a ser adicionado
	 */
	void adiciona(const T& dado) {
		if (listaVazia())
			return adicionaNoInicio(dado);

		auto e = head;

		for (; e->getProximo(); e = e->getProximo()) {}

		e->setProximo(std::make_shared<Elemento<T>>(dado, nullptr));

		++size;
	}
Beispiel #5
0
	/**
	 * @brief      Adiciona na lista, mantendo a ordenação dos elementos
	 *
	 * @param[in]  data  Dado a ser adicionado
	 */
	void adicionaEmOrdem(const T& data) {
		if(listaVazia())
			adicionaNoInicio(data);

		int pos = 0;

		auto e = head;

		while (pos <= size && data > e->getInfo())
			pos++;

		adicionaNaPosicao(data, pos);
	}
Beispiel #6
0
	/**
	 * @brief      Adiciona dado em uma posição especifica da lista
	 *
	 * @param[in]  dado  Dado a ser adicionado
	 * @param[in]  pos   Posição onde o dado vai ser adicionado
	 */
	void adicionaNaPosicao(const T& dado, int pos) {
		if (pos < 0 || pos > size) throw 20;
		if (pos == 0) return adicionaNoInicio(dado);
		if (pos == size) return adiciona(dado);
		auto current = head;
		auto old = current;
		while (--pos) {
			old = current;
			current = current->getProximo();
		}
		old->setProximo(std::make_shared<Elemento<T>>(dado, current));
		++size;
	}
 // Adiciona dado na posição definida pela comparação de grandeza
 void adicionaEmOrdem(const T& data) {
  Elemento<T> *atual;
  int pos = 0;
  if (listaVazia())
   return adicionaNoInicio(data);
  atual = head;
  while (atual->getProximo() != NULL && maior(data, atual->getInfo())) {
    atual = atual->getProximo();
    pos++;
  }
  if (maior(data, atual->getInfo()))
   adicionaNaPosicao(data, pos + 1);
  adicionaNaPosicao(data, pos);
 }
/** 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".
*/
    void adicionaNaPosicao(const T& dado, int pos) {
        verificaPosicaoInvalida(pos);
        if (pos == 0) {
            adicionaNoInicio(dado);
            return;
        }
            verificaMemoriaCheia();
            Elemento<T> *anterior = head;
            for (int i = 0; i < pos - 1; i++) {
                anterior = anterior->getProximo();
            }
            Elemento<T> *novo = new Elemento<T>(dado, anterior->getProximo());
            anterior->setProximo(novo);
            size++;
    }
Beispiel #9
0
void ListaEnc<T>::adicionaEmOrdem(const T& dado) {
	if (listaVazia()) {
		return adicionaNoInicio(dado);
	}
	Elemento<T>* atual = cabeca;
	int posicao = 1;
	while (atual->getProximo() != 0 && maior(dado, atual->getInfo())) {
		atual = atual->getProximo();
		posicao++;
	}
	if (maior(dado, atual->getInfo())) {
		return adicionaNaPosicao(dado, posicao + 1);
	}
	adicionaNaPosicao(dado, posicao);
}
 /** 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".
 */
 void adicionaNaPosicao(const T& dado, int pos) {
     this->verificaPosicaoInvalida(pos);
     if (pos == 0) {
         adicionaNoInicio(dado);
         return;
     }
     this->verificaMemoriaCheia();
     Elemento<T> *anterior = sentinel->getProximo();
     for (int i = 0; i < pos - 1; i++) {
         anterior = anterior->getProximo();
     }
     Elemento<T> *novo = new Elemento<T>(dado, anterior->getProximo());
     anterior->setProximo(novo);
     this->defineTamanho(this->retornaTamanho() + 1);
 }
Beispiel #11
0
void ListaCirc<T>::adicionaEmOrdem(const T& data) {
  if (ListaEnc<T>::listaVazia()) {
    return adicionaNoInicio(data);
  }
  Elemento<T>* atual = this->cabeca->getProximo();
  int posicao = 1;
  while (atual->getProximo() != 0 &&
        ListaEnc<T>::maior(data, atual->getInfo())) {
    atual = atual->getProximo();
    posicao++;
  }
  if (ListaEnc<T>::maior(data, atual->getInfo())) {
    return adicionaNaPosicao(data, posicao + 1);
  }
  adicionaNaPosicao(data, posicao);
}
Beispiel #12
0
    /*!
        Adiciona um dado em ordem na lista.
        \param endereço do dado do tipo T que sera inserido em ordem na lista.
    */
	void adicionaEmOrdem(const T& data) {
		printf("Adiciona em ordem errado!\n");
		if (listaVazia())
			adicionaNoInicio(data);
		Elemento<T>* aux;
		int pos;
		aux = head;
		pos = 0;
		while (aux->getProximo() != NULL && maior(data, aux->getInfo())) {
			aux = aux->getProximo();
			pos++;
		}
		if (maior(data, aux->getInfo()))
			adiciona(data);
		adicionaNaPosicao(data, pos);
	}
Beispiel #13
0
    /*!
        Adiciona um elemento na posicao especifica.
        \param dado é o endereço do dado do tipo T que sera inserido na lista.
        \param pos é o lugar do em que o dado sera inserido na lista. (inicio=0)
    */
	void adicionaNaPosicao(const T& dado, int pos) {
		Elemento<T> *elNovo, *ant;
		if (pos > size)
			throw(20);
		if (pos == 0) {
			adicionaNoInicio(dado);
		    return;
		}
		ant = head;
		for (int controle = 0; controle < pos-1; controle++)
			ant = ant->getProximo();
		elNovo = new Elemento<T>(dado, ant->getProximo());
		if (elNovo == NULL)
			throw(20);
		ant->setProximo(elNovo);
		size++;
	}
Beispiel #14
0
	/**
	 * @brief 		Adicona um elemento em ordem crescente
	 *
	 * @param 		data	O valor dado como parâmetro cria um novo objeto da
	 * 						classe elemento, dado = info (ver classe Elemento.hpp)
	 *
	 * @details 	Percorre elemento por elemento checando o dado de parâmetro
	 * 				é maior que o dado da lista, caso seja vai para o próximo
	 * 				elemento, caso não seja utiliza o método adicionaNaPosicao()
	 * 				com o contador que é utilizado na iteração de cada elemento
	 * 				percorrido
	 */
	void adicionaEmOrdem(const T& data) {
		if(listaVazia()) {
			adicionaNoInicio(data);
		} else {
			Elemento<T> *atual = head;
			int pos = 1;
			do {
				if(maior(data, atual->getInfo())) {
					atual = atual->getProximo();
					++pos;
				} else {
					break;
				}
			} while (atual->getProximo() != sentinela);
			adicionaNaPosicao(data, pos);
		}
	}
Beispiel #15
0
void ListaEnc<T>::adicionaEmOrdem(const T& data) {
	Elemento<T>* anterior = head;
	int posicao = 0;
    while (posicao < size && maior(data, anterior->getInfo())) {
    	    anterior = anterior->getProximo();
    	    ++posicao;
    }
    Elemento<T>* novo = new Elemento<T>(data, nullptr);
    if (posicao == 0) {
        adicionaNoInicio(data);
        ++size;
    } else {
        novo -> setProximo(anterior->getProximo());
	    anterior->setProximo(novo);
	    ++size;
    }
}
 // Posicao
 // Adiciona elemento na posicao especificada no parâmetro
 void adicionaNaPosicao(const T& dado, int pos) {
  Elemento<T> *anterior;
  if (pos > size || pos < 0)
   throw 20;
  if (pos == 0) {
   adicionaNoInicio(dado);
   return;
  }
  Elemento<T> *novo = new Elemento<T>(dado, NULL);
  if (novo == NULL)
   throw 20;
  anterior = head;
  for (int i = 0; i < pos - 1; i++)
   anterior = anterior->getProximo();
  novo->setProximo(anterior->getProximo());
  anterior->setProximo(novo);
  size++;
 }
Beispiel #17
0
void ListaEnc<T>::adicionaNaPosicao(const T& dado, int posicao) {
	if (posicaoInvalida(posicao)) {
		throw ExcecaoPosicao();
	}
	if (posicao == 0) {
		return adicionaNoInicio(dado);
	}
	Elemento<T>* novo = new Elemento<T>(dado, 0);
	if (novo == 0) {
		throw ExcecaoListaCheia();
	}
	Elemento<T>* anterior = cabeca;
	for (int i = 0; i < posicao - 1; i++) {
		anterior = anterior->getProximo();
	}
	novo->setProximo(anterior->getProximo());
	anterior->setProximo(novo);
	tamanho++;
}
void ListaEnc<T>::adicionaNaPosicao(const T& dado, int pos) {
  validarPosicaoParaInsercao(pos);

  if (pos == 0)
    return adicionaNoInicio(dado);

  Elemento<T> *novo;
  Elemento<T> *anterior;

  novo = new Elemento<T>(dado, NULL);
  anterior = head;

  for (int i = 0; i < pos - 1; i++) {
    anterior = anterior->getProximo();
  }
  novo->setProximo(anterior->getProximo());
  anterior->setProximo(novo);
  size++;
}
Beispiel #19
0
/**
 *Método que adiciona um objeto da classe ElementoDeLista.
 *
 *
 * @param InfoLista *dado= ponteiro para um objeto da classe InfoLista.
 *
 * @return LISTA_CHEIA = caso a lista em execução já possua o numero de elementos determinado pela variável MAXLISTA.
 * @return ERRO_POSICAO = caso a posição informada seja inválida, ou seja, caso nao esteja entre o inicio e o final da lista.
 * @return tamanho = tamanho final da lista.
 */
int CabecaDeLista::adicionaEmOrdem(InfoLista *dado) {
	ElementoDeLista *atual;
	int posicao;
	if (vazia()) {
		return adicionaNoInicio(dado);
	} else {
		atual = primeiro;
		posicao = 1;
		while (atual->proximo != 0 && maior(dado, atual->info)) {
			atual = atual->proximo;
			posicao++;
		}
		if (maior(dado, atual->info)) {
			return adicionaNaPosicao(dado, posicao + 1);
		} else {
			return adicionaNaPosicao(dado, posicao);
		}
	}
}
/** 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".
*/
    void adicionaEmOrdem(const T& data) {
        Elemento<T> *atual;
        int posicao;
        if (this->listaVazia()) {
            adicionaNoInicio(data);
        } else {
            atual = sentinel->getProximo();
            posicao = 1;
            while (atual->getProximo() != sentinel &&
                    this->maior(data, atual->getInfo())) {
                atual = atual->getProximo();
                posicao++;
            }
            if (this->maior(data, atual->getInfo())) {
                adicionaNaPosicao(data, posicao + 1);
            } else {
                adicionaNaPosicao(data, posicao);
            }
        }
    }
Beispiel #21
0
void ListaCirc<T>::adicionaNaPosicao(const T& dado, int pos) {
  if (ListaEnc<T>::posicaoInvalida(pos)) {
    throw ExcecaoPosicao();
  }
  if (pos == 0) {
    adicionaNoInicio(dado);
    return;
  }
  Elemento<T>* anterior = this->cabeca->getProximo();
  Elemento<T>* novo = new Elemento<T>(dado, 0);
  if (novo == 0) {
    throw ExcecaoListaCheia();
  }
  for (int i = 1; i < pos; i++) {
    anterior = anterior->getProximo();
  }
  novo->setProximo(anterior->getProximo());
  anterior->setProximo(novo);
  this->tamanho++;
}
/** 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".
*/
    void adicionaEmOrdem(const T& data) {
        Elemento<T> *atual;
        int posicao;
        if (listaVazia()) {
            adicionaNoInicio(data);
        } else {
            atual = head;
            posicao = 1;
            while (atual->getProximo() != NULL &&
                  maior(data, atual->getInfo())) {
                atual = atual->getProximo();
                posicao++;
            }
            if (maior(data, atual->getInfo())) {
                adicionaNaPosicao(data, posicao + 1);
            } else {
                adicionaNaPosicao(data, posicao);
            }
        }
    }
Beispiel #23
0
	void adicionaNaPosicao(const T& dado, int pos){
		if (pos < 0 || pos > size)
			throw std::runtime_error("Deu merda");

		if (pos == 0){
			adicionaNoInicio(dado);
			return;
		}
		Elemento<T> *novo = new Elemento<T>(dado);
		Elemento<T> *aux;

		if (novo == 0)
			throw std::runtime_error("Deu merda");
		aux = head;
		for (int i = 1; i < pos; i++)
			aux = aux->_next;
		novo->_next = aux->_next;
		aux->_next = novo;
		size++;
	}
Beispiel #24
0
/**
 * Método que adiciona um elemento da lista.
 *
 * Primeiramente teste se ainda é possivel adicionar um elemento à lista. Caso isso não seja verdadeiro ele retorna uma constante LISTA_CHEIA.
 *
 * @param InfoLista *dado= ponteiro para um objeto da classe InfoLista.
 * @return LISTA_CHEIA = constante que representa a falta de espaço na Lista.
 * @return tamanho = inteiro que informa a posição onde o dado foi inserido.
 */
int CabecaDeLista::adiciona(InfoLista *dado) {
	if (vazia()) {
		return adicionaNoInicio(dado);
	}
	ElementoDeLista *novo = new ElementoDeLista();
	if (novo == 0) {
		return LISTA_CHEIA;
	}
	ElementoDeLista *anterior;
	anterior = primeiro;
	while (anterior->proximo != 0) {
		anterior = anterior->proximo;
	}
	anterior->proximo = novo;
	novo->proximo = 0;
	novo->info = dado;
	tamanho++;
	return 0; // return adicionaNaPosicao(dado,tamanho+1);

}
int adicionaEmOrdemNaPosicao(ListaEnc *lista){
    TipoInfo *info;
    char valor1[30], valor2[30], i;
    int valor3 = 0, armazena0 = 0, armazena1 = 0, testa = 0;

    system("clear");

    printf("Informe o nome do usuario: ");
    scanf("%s", valor1);

    printf("Informe o curso do usuario: ");
    scanf("%s", valor2);

    printf("Informe a fase em que se encontra o usuario: ");
    scanf("%d", &valor3);

    system("clear");
    info = criaInfo(valor1, valor2, valor3);
    Elemento *atual = lista->cabeca;

    for(i=0; i<lista->tamanho; i++){
        if(i == 0){
            armazena0 = lista->cabeca->info->fase;
            armazena1 = i;
        }else if(i > 0 && i<lista->tamanho){
            atual = atual->proximo;
            testa = atual->info->fase;
            if(armazena0 < testa){
                armazena0 = testa;
                armazena1 = i;
            }
        }
    }

    if(armazena1 == 0)
        adicionaNoInicio(lista, info);
    if(armazena1 > 0)
        adicionaNaPosicao(lista, info, armazena1);

    return 0;
}
Beispiel #26
0
	/**
	 * @brief      Adiciona o dado na posição
	 *
	 * @param[in]  dado  Dado a ser inserido
	 * @param[in]  pos   Posição para inserir o dado
	 */
	void adicionaNaPosicao(const T& dado, int pos) {
		if(pos > size || pos < 0)
			throw std::runtime_error("posicao must be smaller than "
									"ultimo+1 and greater than zero");

		if (pos == 0)
			return adicionaNoInicio(dado);

		if (pos == size+1)
			return adiciona(dado);

		auto e = head;

		for (int i = 0; i < pos-1; ++i)
			e = e->getProximo();


		e->setProximo(std::make_shared<Elemento<T>>(dado, e->getProximo()));

		++size;
	}
Beispiel #27
0
	/**
	 * @brief      Adiciona um elemento na posição desejada
	 *
	 * @param      dado  O valor dado como parâmetro cria um novo objeto da
	 *                   classe elemento, dado = info (ver classe Elemento.hpp)
	 *
	 * @param      pos   Posição desejada para o elemento ser colocado
	 *
	 * @details    Caso a posição seja 0 chama o método adicionaNoInicio(), pois
	 *             é um caso epecífico Uma explicação de como é feito os índices
	 *             de posição desta lista podem ser encontrada na descrição do
	 *             método posicao()
	 */
	void adicionaNaPosicao(const T& dado, int pos) {
		if(pos > size || pos < 0) {
			throw std::runtime_error("Posição Inválida");
		}
		if(pos == 0) {
			adicionaNoInicio(dado);
		} else {
			Elemento<T> *atual = head;
			Elemento<T> *novo = new Elemento<T>(dado, nullptr);
			if(novo == nullptr) {
				throw std::runtime_error("Sem Espaço na Memória");
			} else {
				for(int i = 0; i < (pos-1); i++) {
					atual = atual->getProximo();
				}
				novo->setProximo(atual->getProximo());
				atual->setProximo(novo);
				++size;
			}
		}
	}
int adicionaNoFim(ListaEnc *lista, TipoInfo *dados){
    int i;

    if(estah_vazia(lista))
        return adicionaNoInicio(lista, dados);
    else{
        Elemento *aux = lista->cabeca;
        for(i=0; i < lista->tamanho-1; i++)
            aux = aux->proximo;

        Elemento *novo = (Elemento*) malloc(sizeof(Elemento));
        if(novo != NULL){
            novo->proximo = NULL;
            novo->info = dados;
            aux->proximo = novo;
            lista->tamanho++;
            return lista->tamanho;
        }
        return 0;
    }
    system("clear");
}
Beispiel #29
0
void ListaEnc<T>::adicionaNaPosicao(const T& dado, int pos) {
	if (pos > size || pos < 0) {
		throw std::runtime_error("Erro Posição");
	} else {
		if (pos == 0) {
			adicionaNoInicio(dado);
			return;
		} else {
			Elemento<T>* novo = new Elemento<T>(dado, nullptr);
			if (novo == nullptr) {
				throw std::runtime_error("Lista Cheia");
			} else {
				Elemento<T>* anterior = head;
				for (int i = 0; i < pos-1; ++i) {
					anterior = anterior->getProximo();
				}
				novo -> setProximo(anterior->getProximo());
				anterior->setProximo(novo);
				++size;
			}
		}
	}
}
Beispiel #30
0
/**
 NOME DA FUNÇÃO: adicionarContato
 ALUNOS: Pedro Paulo e Felipe dos Santos
 PROPÓSITO:
	É responsável por obter o contato a ser armazenado e encaminhá-lo à lista de maneira apropriada e por fim
	informar se tudo aconteceu de maneira correta.

 PARÂMETROS:
 nenhum

 VALOR DE RETORNO:
 nenhum

 CHAMA: exibeMenuSecundario, adiciona, adicionaNoInicio, adicionaNaPosicao, exibirMensagemErro

 CHAMADA DE: main
 */
void adicionarContato() {
	int opcao, posicao, resultado;
	tAgenda elemento;

	puts("Forneça o nome do contato: ");
	getchar();
	scanf("%[^\n]", &elemento.nome);
	puts("Forneça o número de telefone: ");
	scanf("%d", &elemento.numero);

	exibeMenuSecundario("Adicionar no");
	puts("3 - Adicionar em ordem");
	scanf("%d", &opcao);

	switch (opcao) {
	case 0:
		resultado = adiciona(elemento);
		break;
	case 1:
		resultado = adicionaNoInicio(elemento);
		break;
	case 2:
		puts("Forneça a posição a ser adicionada");
		scanf("%d", &posicao);
		resultado = adicionaNaPosicao(elemento, posicao);
		break;
	case 3:
		resultado = adicionaEmOrdem(elemento);
		break;
	default:
		puts("Opção Inválida");
		break;
	}

	if (resultado != 0)
		exibirMensagemErro(resultado);
}