void Merge(Lista * dest, Lista * source1, Lista * source2) { int node; while(!listaVazia(source1)) { removeDoInicio(source1, &node); insereNoFim(dest, &node); } while(!listaVazia(source2)) { removeDoInicio(source2, &node); insereNoFim(dest, &node); } }
const ElementoGeometrico* ListaElementosGeometricos::retiraDoInicio(){ if (listaVazia()) return new ElementoGeometrico(ElementoGeometrico::null); return head->getProximo()->getInfo(); }
T ListaEnc<T>::retiraEspecifico(const T& dado) { if (listaVazia()) { throw std::runtime_error("Lista Vazia"); } else { return retiraDaPosicao(posicao(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; } } } }
/* * @brief Metodo adicionaDuplo * @details Metodo para adicionar um elemento na Lista * @param O parametro 'dado' é o elemento especifico a ser adicionado da lista * Caso a lista esteja Vazia chama o metodo 'adicionaNoInicio' e passa como parametro o dado a ser adicionado * Caso contrario chama o metodo 'adicionaNaPosicao' e passa como parametro o dado a ser adicionado e o tamanho da Lista */ void adicionaDuplo(const T& dado) { if (listaVazia()) { adicionaNoInicioDuplo(dado); } else { adicionaNaPosicaoDuplo(dado, tamanho); } }
/** * @brief Remove o dado que está no inicio da lista * * @return Dado que foi removido */ T retiraDoInicio() { if (listaVazia()) throw 20; T retorno = head->getInfo(); head = head->getProximo(); --size; return retorno; }
/*! * \brief Funcao retiraEspecificoDuplo * \param dado passado por referencia e um tipo generico constante * que representa o dado que deve ser retirado da lista. * \return uma chamada para a funcao retiraDaPosicao. * \sa listaVazia(), posicaoDuplo(...), retiraDaPosicaoDuplo(...) * * Se a lista nao estiver vazia, entao chama a funcao posicaoDuplo * para ter o local do dado passado como argumento e passa esse * local para a funcao retiraDaPosicaoDuplo que fara o processo * de retirada do dado. */ T retiraEspecificoDuplo(const T &dado) { if (listaVazia()) { throw "problema"; } else { return retiraDaPosicaoDuplo(posicaoDuplo(dado)); } }
/* * @brief Metodo retiraDuplo * @details Metodo para retirar um elemento da Lista * @return Retorna a chamada do metodo 'retiraDaPosicao' com parametro 'tamanho-1' */ T retiraDuplo() { if (listaVazia()) { throw("Lista vazia"); } else { return retiraDaPosicaoDuplo(tamanho-1); } }
/* * @brief Metodo retiraEspecificoDuplo * @details Metodo para retirar um elemento especifico da Lista * @param O parametro 'dado' é o elemento especifico a ser retirado da lista * @return Retorna o dado a ser retirado */ T retiraEspecificoDuplo(const T& dado) { if (listaVazia()) { throw("Lista Vazia"); } else { return (retiraDaPosicaoDuplo(posicaoDuplo(dado))); } }
/** * @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 retiraDoInicioDuplo(), pois * é um caso específico */ T retiraDaPosicaoDuplo(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 retiraDoInicioDuplo(); } else { ElementoDuplaEnc<T> *anterior = head; ElementoDuplaEnc<T> *eliminar; for(int i = 0; i < (pos-1); i++) { anterior = anterior->getProximo(); } eliminar = anterior->getProximo(); T volta = eliminar->getInfo(); eliminar->getProximo()->setAnterior(anterior); anterior->setProximo(eliminar->getProximo()); delete eliminar; --size; return volta; } } }
/** * @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; }
//ETC template<class T>int Lista<T>::verUltimo(){ if(listaVazia()) return ERROLISTAVAZIA; else{ return ultimo; } };
T ListaEnc<T>::retiraEspecifico(const T& dado) { if (listaVazia()) throw ERROLISTAVAZIA; int pos = posicao(dado); return retiraDaPosicao(pos); }
/* * @brief Metodo para retirar elementos do vetor * @details Verifica se a lista não está Vazia * Decrementa a variavel 'fim' e retorna o vetor 'dados[]' com a posição 'fim +1' */ T retira() { if (listaVazia()) { throw(ERROLISTAVAZIA); } else { fim -= 1; return (dados[fim+1]); } }
template<class T>int Lista<T>::retira(){ if(listaVazia()) return ERROLISTAVAZIA; else{ ultimo--; return dados[ultimo+1]; } };
/** Retira o último elemento da Lista. * Este método retira o último elemento da Lista e decrementa o ponteiro da Lista. * @see listaVazia() * @exception ExcecaoListaVazia Exceção que indica que um dado não pode ser retirado, pois a lista já está vazia. * @return o dado do tipo T que foi retirado do final da Lista. */ T retira() { if (!listaVazia()) { ultimo = ultimo - 1; return dados[ultimo + 1]; } else { throw ExcecaoListaVazia; } }
/** * @brief Retorna o ponteiro para o dado armazenado na lista * * @param[in] dado Dado para procurar * * @return Ponteiro para o dado armazenado na lista */ T* posicaoMem(const T& dado) const { if (listaVazia()) throw std::runtime_error("lista vazia"); for (auto e = head; e->getProximo() != nullptr; e = e->getProximo()) if (e->getInfo() == dado) return &e->getInfo(); }
void ListaEnc<T>::eliminaDoInicio() { if (listaVazia()) throw ERROLISTAVAZIA; Elemento<T> *deleted = head; head = deleted->getProximo(); delete (deleted); size--; }
void ListaEnc<T>::eliminaDoInicio() { if (listaVazia()) { throw ExcecaoListaVazia(); } Elemento<T>* saiu = cabeca; cabeca = saiu->getProximo(); tamanho--; delete saiu; }
//comentário T retiraEspecifico(T dado) { if(listaVazia()) throw 20; int pos = posicao(dado); if (pos < 0) throw 20; return retiraDaPosicao(pos); }
void ListaDupla<T>::eliminaDoInicioDuplo() { if (listaVazia()) { throw ExcecaoListaVazia(); } ElementoDuplo<T>* saiu = cabeca; cabeca = saiu->getProximo(); cabeca->setAnterior(0); tamanho--; delete saiu; }
/** * @brief Retira o dado armazenado no head e o retorna o novo head passa a ser head->getProximo() * * @return Dado removido */ T retiraDoInicio() { if (listaVazia()) throw std::runtime_error("lista vazia"); T info_rmv = head->getInfo(); head = head->getProximo(); --size; return info_rmv; }
/* Remove o elemento que esta no inicio da lista. Retorna 0 caso a lista esteja vazia */ int removeInicio(Lista *p_l, elem_t *p_e){ No_lista *aux; if(listaVazia(p_l)) return 0; aux = *p_l; *p_l = aux->prox; *p_e = aux->info; free(aux); return 1; }
/** 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() { if (listaVazia()) { throw ExcecaoListaVazia; } else { Elemento<T>* saiu = head; head = saiu->getProximo(); size--; delete saiu; } }
/* * @brief Metodo para ver se determinado dado esta presente na Lista * @details Verifica se a lista esta vazia, tenha alguma informação na lista * é iniciado um 'FOR' para comparar a variavel 'dado' que é passada como parametro * e o array 'dados[]', caso ache tenha uma comparação positiva é retornado verdadeiro */ bool contem(T dado) { if (listaVazia()) { return false; } for (int i = 0; i < fim + 1; i++) if (dado == dados[i]) { return true; } return false; }
void ListaEnc<T>::eliminaDoInicio() { if(listaVazia()) { throw std::runtime_error("Lista Vazia"); } else { Elemento<T>* temp = head->getProximo(); delete head; head = temp; --size; } }
// Elimina o primeiro elemento da Lista e sua respectiva informação void eliminaDoInicio() { Elemento<T> *saiu; if (listaVazia()) throw 20; saiu = head; head = saiu->getProximo(); size--; // delete saiu->getInfo(); delete saiu; }
/*! \return Retira o primeiro elemento da lista. */ void eliminaDoInicio() { Elemento<T>* sai; if (listaVazia()) throw(20); sai = head; head = sai->getProximo(); size--; //printf("Endereco do evento eliminado = %d\n", sai->getInfo()); sai->~Elemento(); }
/** * @brief Retorna o último elemento da lista */ T mostra() { if(listaVazia()) { throw std::runtime_error("Lista Vazia"); } Elemento<T> *atual = head; while(atual->getProximo() != head) { atual = atual->getProximo(); } return atual->getInfo(); }
T ListaDupla<T>::mostra(int pos) { if (listaVazia()) { throw ExcecaoListaVazia(); } ElementoDuplo<T>* mostra = cabeca; for (int i = 0; i < tamanho - 1; i++) { mostra = mostra->getProximo(); } return mostra->getInfo(); }