// 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);
}
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);
}
//fim
void ListaElementosGeometricos::adiciona(const ElementoGeometrico*& dado){
if (size == 0)
adicionaNoInicio(dado);
else
adicionaNaPosicao(dado,size-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);
}
/**
NOME DA FUNÇÃO: adicionaEmOrdem
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
partindo do pressuposto que a lista está previamente ordenada, adiciona, se possível, um novo contato na
sua posição correspondente para manter a lista ordenada.
PARÂMETROS:
nome tipo valor/referência descrição
---------------------------------------------------------------------
dado tAgenda valor elemento a ser adicionado
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
-- int 0 em caso de sucesso, código de erro em caso de problema
*/
int adicionaEmOrdem(tAgenda dado) {
int pos = 0;
while (pos <= aLista.ultimo && maior(dado, aLista.elem[pos]))
pos++;
return adicionaNaPosicao(dado, pos);
}
void Lista<T>::adicionaEmOrdem(T dado) {
if (listaCheia()) {
throw ExcecaoListaCheia();
}
int posicao = 0;
while((posicao <= ultimo) && (maior(dado, lista[posicao]))) {
posicao++;
}
adicionaNaPosicao(dado, posicao);
}
/**
*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);
}
}
}
int Lista::adicionarEmOrdem(const char* lancamento) {
if (listaCheia())
return -1;
int pos = 0;
while (pos <= ultimo && strcmp(lancamento, lista[pos]) > 0) {
pos++;
}
return adicionaNaPosicao(lancamento, pos);
}
/** 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);
}
}
}
/** 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);
}
}
}
//comentário
void adicionaEmOrdem(T dado)
{
if(listaCheia())
throw 20;
int pos = 0;
while(pos <= ultimo && (dado > dados[pos]))
{
pos++;
adicionaNaPosicao(dado, pos);
}
}
/*
* @brief Metodo adicionar elementos em ordem no vetor
* @details Verifica se a lista não está Cheia
* Cria uma variavel auxiliar de inteiros chamada 'pos'
* Faz comparações dos parametros 'dado' e 'dados[pos]' atraves do metodo 'maior()'
* Retorna o metodo 'adicionaNaPosicao()' e passa como parametros 'dado' e a variavel 'pos'
*/
void adicionaEmOrdem(T dado) {
int pos;
if (listaCheia()) {
throw(ERROLISTACHEIA);
} else {
pos = 0;
while (pos < fim && maior(dado, dados[pos])) {
pos += 1;
}
return (adicionaNaPosicao(dado, pos));
}
}
void adicionaEmOrdem(const T& data){
Elemento<T> *novo = new Elemento<T>(data);
Elemento<T> *aux;
aux = head;
int i = 0;
for (; i < size; i++){
if(maior(*aux->info, data))
break;
aux = aux->_next;
}
adicionaNaPosicao(data, i);
}
/** Adiciona um novo elemento seguindo a ordem da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento em determinada posição.
* @param dado O dado a ser inserido na Lista.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaEmOrdem(T dado) {
if (!listaCheia()) {
int i;
for(i = 0; i <= ultimo; i++) {
if (!maior(dado, dados[i])) {
break;
}
}
adicionaNaPosicao(dado, i);
} else {
throw ExcecaoListaCheia;
}
}
/**
* @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);
}
/** Adiciona um novo elemento seguindo a ordem da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento em determinada posição.
* @param dado O dado a ser inserido na Lista.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaEmOrdem(T dado) {
int posicao = 0;
if (listaCheia()) {
throw ExcecaoListaCheia;
} else {
for(int i = 0; i <= ultimo; i++) {
if (maior(dado, dados[posicao])) {
posicao++;
} else {
break;
}
}
adicionaNaPosicao(dado, 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);
}
/**
* @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);
}
}
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;
}
/**
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);
}
int main(void){
ListaEnc *lista;
TipoInfo *info, *aux;
int escolha = -1;
char valor1[30];
char valor2[30];
int valor3 = -1000;
int pos = -1;
int flag=0;
while ((escolha = menu())!= 0){
switch (escolha){
case 1:
flag++;
lista = criaLista(); break;
case 2:
valor3 = estah_vazia(lista);
system("clear");
if(valor3 == 1)
printf("A lista esta vazia\n");
else
printf("A lista nao esta vazia\n");
printf("\nObs: Quando a lista encadeada esta vazia, adicionar registro no fim\ne no inicio corresponde a uma mesma operacao.\n");
break;
case 3:
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);
adicionaNoInicio(lista, info); break;
case 4:
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");
if(lista->tamanho > 1){
imprime_lista(lista);
do{
printf("Podera inserir registros entre o 1o e o ultimo registro inclusive\n");
printf("Informe a posicao que desejas inserir este registro: ");
scanf("%d", &pos); }while(pos <= 0 || pos >= lista->tamanho);
info = criaInfo(valor1, valor2, valor3);
adicionaNaPosicao(lista, info, pos);
}else if(lista->tamanho <= 1 ){
info = criaInfo(valor1, valor2, valor3);
adicionaNoInicio(lista, info);
}
break;
case 5:
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);
adicionaNoFim(lista, info); break;
case 6:
aux = retiraDoInicio(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase); break;
case 7:
aux = retiraDoFim(lista);
system("clear");
printf("Registro retirado\n\nNome de usuario: %s\nCurso do usuario: %s\nFase em que o usuario se encontra: %d", aux->nome, aux->curso, aux->fase); break;
case 8:
imprime_lista(lista); break;
case 9:
if(flag == 1){
flag--;
destroi_lista(lista);
}else
printf("Nao ha lista para destruir\n");
}
}
if(flag == 1){
destroi_lista(lista);
}
return 0;
}
/** Adiciona um novo elemento no início da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento no início da lista, ou seja, adiciona esse dado na posição zero.
* @param dado O dado que será inserido dentro da lista. Precisa ser do mesmo tipo de dados que a lista armazena.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo addo não pode ser adicionado, pois a lista já está cheia.
*/
void adicionaNoInicio(T dado) {
adicionaNaPosicao(dado, 0);
}
/** Adiciona um novo elemento no final da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento no final da lista, ou seja, adiciona esse dado na última posição da lista.
* @param dado O dado que será inserido dentro da lista. Precisa ser do mesmo tipo de dados que a lista armazena.
* @see listaCheia()
* @exception ExcecaoListaCheia Exceção que indica que um novo dado não pode ser adicionado, pois a lista já está cheia.
*/
void adiciona(T dado) {
adicionaNaPosicao(dado, ultimo + 1);
}
void Lista<T>::adiciona(T dado) {
return adicionaNaPosicao(dado, ultimo + 1);
}
void Lista<T>::adicionaNoInicio(T dado) {
return adicionaNaPosicao(dado, 0);
}
/** Adiciona um novo elemento no final da Lista.
* Este método recebe um dado do tipo T e adiciona este elemento no final da lista, ou seja, adiciona esse dado na última posição da lista.
* @param dado O dado que será inserido dentro da lista.
* @see adicionaNaPosicao(const T& dado, int pos)
* @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 adiciona(const T& dado) {
adicionaNaPosicao(dado, this->retornaTamanho());
}
void ListaCirc<T>::adiciona(const T& dado) {
return adicionaNaPosicao(dado, this->tamanho);
}
void adiciona(const T& dado){
adicionaNaPosicao(dado, size);
}
/**
NOME DA FUNÇÃO: adicionaNoInicio
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
adiciona, se possível, um contato na primeira posição da lista. Ao final retorna o sucesso ou não da
operação.
PARÂMETROS:
nome tipo valor/referência descrição
---------------------------------------------------------------------
dado tAgenda valor elemento a ser adicionado
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
-- int 0 em caso de sucesso, código de erro em caso de problema
*/
int adicionaNoInicio(tAgenda dado) {
return adicionaNaPosicao(dado, 0);
}
void ListaEnc<T>::adiciona(const T& dado) {
return adicionaNaPosicao(dado, size);
}
