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();
}
