/** NOME DA FUNÇÃO: retirarContato ALUNOS: Pedro Paulo e Felipe dos Santos PROPÓSITO: É responsável por gerenciar as operações de remoção de contatos e delegá-las apropriadamente à lista e informar se tudo aconteceu de maneira correta. PARÂMETROS: nenhum VALOR DE RETORNO: nenhum CHAMA: exibeMenuSecundario, retira, retiraDoInicio, retiraDaPosicao, exibirMensagemErro CHAMADA DE: main */ void retirarContato() { int opcao, posicao, resultado; exibeMenuSecundario("Remover do"); scanf("%d", &opcao); switch (opcao) { case 0: resultado = retira(); break; case 1: resultado = retiraDoInicio(); break; case 2: puts("Forneça a posição a ser removida"); scanf("%d", &posicao); resultado = retiraDaPosicao(posicao); break; default: puts("Opção Inválida"); break; } if (resultado != 0) exibirMensagemErro(resultado); }
/** * @brief Retira o dado na posição pos e o retorna * * @param[in] pos Posição para retirar * * @return O dado retirado */ T retiraDaPosicao(int pos) { if(pos >= size || pos < 0) throw std::runtime_error("posicao must be smaller than " "ultimo+1 and greater than zero"); if (listaVazia()) throw std::runtime_error("lista vazia"); if (pos == 0) return retiraDoInicio(); if (pos == size) return retira(); auto e = head; for (int i = 0; i < pos-1; ++i) e = e->getProximo(); T dado = e->getProximo()->getInfo(); e->setProximo(e->getProximo()->getProximo()); --size; return dado; }
T ListaEnc<T>::retiraDaPosicao(int pos) { if (listaVazia()) { throw std::runtime_error("Lista Vazia"); } else { if (pos > size-1 || pos < 0) { throw std::runtime_error("Erro Posição"); } else { if (pos == 0) { return retiraDoInicio(); } else { Elemento<T>* anterior = head; Elemento<T>* eliminar; for (int i = 0; i < pos-1; ++i) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); anterior->setProximo(eliminar->getProximo()); --size; T dado = eliminar->getInfo(); delete eliminar; return dado; } } } }
/** * Método que retira o elemento da lista que esta armazenado na posição recebida como parametro. * * Prara isso ele testa se a posicao recebida por parametro é válida, isto é, se existe algum objeto armazenado na mesma. * * @param posicao = inteiro que determina a localização do dado a ser retirado. * * @return 0(null) = Caso não seja possível retirar. * @return InfoLista = ponteiro para um objeto da classe InfoLista. */ InfoLista* CabecaDeLista::retiraDaPosicao(int posicao) { ElementoDeLista *anterior, *eliminar; InfoLista *volta; if (vazia()) { std::cout << "Lista vazia." << std::endl; return 0; } if (posicao > tamanho || posicao < 0) { std::cout << "Posição inválida." << std::endl; return 0; } else { if (posicao == 1) { return retiraDoInicio(); } else { anterior = primeiro; for (int i = 0; i < posicao - 2; i++) { anterior = anterior->proximo; } eliminar = anterior->proximo; volta = eliminar->info; anterior->proximo = eliminar->proximo; tamanho--; delete eliminar; return volta; } } }
/*! \return Retorna o dado do tipo T da posição especificada. \param pos eh a posicao do elemento cujo dado sera retirado da lista. (elemento é apagado) */ T retiraDaPosicao(int pos) { T dado; Elemento<T> *ant, *sai; if (pos >= size) throw(20); if (pos == 0) return retiraDoInicio(); ant = head; for (int controle = 0; controle < pos-1; controle++) ant = ant->getProximo(); sai = ant->getProximo(); dado = sai->getInfo(); ant->setProximo(sai->getProximo()); size--; return dado; sai->~Elemento(); }
// Retira da lista o elemento que ocupa a posicao passada como paramêtro T retiraDaPosicao(int pos) { Elemento<T> *anterior, *eliminar; T volta; if (pos >= size) throw 20; if (pos == 0) return retiraDoInicio(); anterior = head; for (int i = 0; i < pos - 1; i++) anterior = anterior->getProximo(); eliminar = anterior->getProximo(); volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); size--; delete eliminar; return volta; }
/** * @brief Retira dado de uma posição espesifica * * @param[in] pos Posição do dado que vai ser removido * * @return Dado que foi removido */ T retiraDaPosicao(int pos) { ++pos; if (listaVazia()) throw 20; if (pos < 0 || pos > size) throw 20; if (pos == 0) return retiraDoInicio(); if (pos == size) return retira(); auto current = head; auto old = current; while (--pos) { old = current; current = current->getProximo(); } T retorno = current->getInfo(); old->setProximo(current->getProximo()); --size; return retorno; }
/** 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 Encadeada. * @param pos A posição do dado que se deseja retirar. * @see retiraDoInicio() * @see retornaAnterior(int pos) * @return um objeto T que foi retirado da posição especificada. Retorna NULL se não conseguiu pegar um dado dessa posição. */ T retiraDaPosicao(int pos) { T volta; verificaPosicaoInvalida(pos); if (pos == 0) { retiraDoInicio(); } else { Elemento<T> *anterior = head; for (int i = 0; i < pos - 2; i++) { anterior = anterior->getProximo(); } Elemento<T> *eliminar = anterior->getProximo(); volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); delete eliminar; size--; } return volta; }
T ListaCirc<T>::retiraDaPosicao(int pos) { if (ListaEnc<T>::posicaoInvalida(pos)) { throw ExcecaoPosicao(); } if (pos == 0) { return retiraDoInicio(); } Elemento<T>* anterior = this->cabeca->getProximo(); for (int i = 1; i < pos - 1; i++) { anterior = anterior->getProximo(); } Elemento<T>* eliminar = anterior->getProximo(); T volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); this->tamanho--; delete eliminar; return volta; }
/** 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 circular simples. * @param pos A posição do dado que se deseja retirar. * @see retiraDoInicio() * @see retornaAnterior(int pos) * @return um objeto T que foi retirado da posição especificada. Retorna NULL se não conseguiu pegar um dado dessa posição. */ T retiraDaPosicao(int pos) { T volta; this->verificaPosicaoInvalida(pos); if (pos == 0) { retiraDoInicio();// return; } else { Elemento<T> *anterior = sentinel->getProximo(); for (int i = 0; i < pos - 2; i++) { anterior = anterior->getProximo(); } Elemento<T> *eliminar = anterior->getProximo(); volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); delete eliminar; this->defineTamanho(this->retornaTamanho() - 1); } return volta; }
T ListaEnc<T>::retiraDaPosicao(int posicao) { if (posicaoInvalida(posicao)) { throw ExcecaoPosicao(); } if (posicao == 0) { return retiraDoInicio(); } Elemento<T>* anterior = cabeca; for (int i = 0; i < posicao - 2; i++) { anterior = anterior->getProximo(); } Elemento<T>* eliminar = anterior->getProximo(); T volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); tamanho--; delete eliminar; return volta; }
T retiraDaPosicao(int pos){ if (pos >= size || pos < 0) throw std::runtime_error("Posição inválida"); Elemento<T> *aux, *eliminar; T retorno; if (pos == 0) return retiraDoInicio(); aux = head; for (int i = 0; i < pos-1; i++) aux = aux->_next; eliminar = aux->_next; retorno = *aux->info; aux->_next = eliminar; size--; delete eliminar; return retorno; }
/** * @brief Retira o dado no final da lista e o retorna * * @return O dado retirado */ T retira() { if (listaVazia()) throw std::runtime_error("lista vazia"); if (size == 1) return retiraDoInicio(); auto e = head; for (; e->getProximo()->getProximo(); e = e->getProximo()) {} // T data = e->getInfo(); T data = e->getProximo()->getInfo(); e->setProximo(nullptr); --size; return data; }
T ListaEnc<T>::retiraDaPosicao(int pos) { if (listaVazia()) throw ERROLISTAVAZIA; if (pos > (size - 1)) throw ERROPOSICAO; if (pos == 0) return retiraDoInicio(); Elemento<T> *walkingDead = head; Elemento<T> *anterior; for (int i = 0; i < pos; ++i) { anterior = walkingDead; walkingDead = walkingDead->getProximo(); } anterior->setProximo(walkingDead->getProximo()); T retorno = walkingDead->getInfo(); delete (walkingDead); size--; return retorno; }
TipoInfo *retiraDoFim(ListaEnc *lista){ int i; if(estah_vazia(lista)) return NULL; else{ if(lista->tamanho == 1) return retiraDoInicio(lista); else{ Elemento *aux = lista->cabeca; for(i=0; i < lista->tamanho-2; i++) aux = aux->proximo; Elemento *e = aux->proximo; TipoInfo *info = e->info; aux->proximo = NULL; lista->tamanho--; free(e); return info; } } system("clear"); }
/** * @brief Retira um elemento de uma posição deseja e retorna seu dado * * @param Posição do elemento a ser retirado * * @details Caso a posição seja 0, chama o metódo retiraDoInicio(), pois * é um caso específico */ T retiraDaPosicao(int pos) { if(listaVazia()) { throw std::runtime_error("Lista Vazia"); } if(pos > size-1 || pos < 0) { throw std::runtime_error("Posição Inválida"); } else { if(pos == 0) { return retiraDoInicio(); } else { Elemento<T> *anterior = head; Elemento<T> *eliminar; for(int i = 0; i < (pos-1); i++) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); T volta = eliminar->getInfo(); anterior->setProximo(eliminar->getProximo()); delete eliminar; --size; return volta; } } }
TipoInfo *retiraDoFim(ListaEnc *lista){ int i; if(estah_vazia(lista)) return NULL; else{ if(lista->tamanho == 1) return retiraDoInicio(lista); else{ Elemento *aux = lista->cabeca; for(i=0; i < lista->tamanho-2; i++) aux = aux->proximo; printf("%s %s %d\n", aux->info->nome, aux->info->curso, aux->info->fase); //Elemento *e = aux->proximo; //TipoInfo *info = e->info; //aux->proximo = NULL; //lista->tamanho--; //free(e); //return info; } } system("clear"); }
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; }
/** Elimina um elemento no começo da Lista Encadeada. * Este método elimina o primeiro elemento da Lista Encadeada, ou seja, destrói o objeto sem retornar qualquer valor. * Chama o método "retiraDoInicio()" e caso este método retorne um objeto T, apaga esse objeto da memória. * @see retiraDoInicio() * @exception ExcecaoListaVazia Exceção que indica que o dado não pode ser eliminado pois a lista está vazia. */ void eliminaDoInicio() { T elemento = retiraDoInicio(); delete elemento->getInfo(); delete elemento; }