/**
* @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;
}
/**
* 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);
}
/**
* @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;
}
/**
* @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);
}
/**
* @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++;
}
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);
}
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);
}
/*!
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);
}
/*!
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++;
}
/**
* @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);
}
}
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++;
}
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++;
}
/**
*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);
}
}
}
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);
}
}
}
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++;
}
/**
* 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;
}
/**
* @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;
}
/**
* @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");
}
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;
}
}
}
}
/**
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);
}