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