void ListaDupla<T>::adicionaEmOrdem(const T& data) { if (listaVazia()) { return adicionaNoInicioDuplo(data); } ElementoDuplo<T>* atual = cabeca; int posicao = 1; while (atual->getProximo() != 0 && maior(data, atual->getInfo())) { atual = atual->getProximo(); posicao++; } if (maior(data, atual->getInfo())) { return adicionaNaPosicaoDuplo(data, posicao + 1); } adicionaNaPosicaoDuplo(data, posicao); }
/* * @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 Metodo adicionaEmOrdem * @details Metodo para adicionar elementos em uma determinada ordem na Lista * @param O parametro 'data' é o elemento que sera adicionado na Lista * É criado um ponteiro chamado 'atual' e uma variavel de inteiro 'pos' para auxiliar no funcionamento do metodo */ void adicionaEmOrdem(const T& data) { ElementoDuplo<T> *atual; int pos; if (listaVazia()) { return (adicionaNoInicioDuplo(data)); } else { atual = sentinela->getProximo(); pos = 1; while (atual->getProximo() != NULL && maior(data, atual->getInfo())) { atual = atual->getProximo(); pos += 1; } if (maior(data, atual->getInfo())) { (adicionaNaPosicaoDuplo(data, (pos+1))); } else { (adicionaNaPosicaoDuplo(data, pos-1)); } } }
void adicionaEmOrdem(const T& data) { Elemento2<T> *atual; int pos; if (listaVazia()) { return adicionaNoInicioDuplo(data); } atual = head; pos = 0; while (atual->getProximo() != NULL && maior(data, atual->getInfo())) { atual = atual->getProximo(); pos++; } if (maior(data, atual->getInfo())) { adicionaNaPosicaoDuplo(data, pos+1); } else { adicionaNaPosicaoDuplo(data, pos); } }
/*! \param data um elemento a ser inserido em sequência na lista \sa adicionaDuplo(), adicionaNoInicioDuplo(), adicionaNaPosicaoDuplo() */ void adicionaEmOrdem(const T& data) { ElementoDuplo<T> *aux = head->getProximo(); if (listaVazia()) { return adicionaNoInicioDuplo(data); } int pos = 1; while (pos < size && maior(data, aux->getInfo())) { aux = aux->getProximo(); pos++; } adicionaNaPosicaoDuplo(data, 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". * @see verificaMemoriaCheia(); * @see adicionaNoInicioDuplo(data); * @see adicionaNaPosicaoDuplo(data, posicao); */ virtual void adicionaEmOrdem(const T& data) { verificaMemoriaCheia(); ElementoDuplo<T>* atual; int posicao; if (listaVazia()) { adicionaNoInicioDuplo(data); } else { atual = head; posicao = 0; while (atual->getProximo() != NULL && maior(data, atual->getInfo())) { atual = atual->getProximo(); posicao++; } if (maior(data, atual->getInfo())) { adicionaNaPosicaoDuplo(data, posicao + 1); } else { adicionaNaPosicaoDuplo(data, posicao); } } }
/** * @brief Adicona um elemento em ordem crescente * * @param data O valor dado como parâmetro cria um novo objeto da * classe ElementoDuplaEnc, dado = info (ver classe * ElementoDuplaEnc.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()) { adicionaNoInicioDuplo(data); } else { ElementoDuplaEnc<T> *atual = head; int pos = 0; do { if(maior(data, atual->getInfo())) { atual = atual->getProximo(); ++pos; } else { break; } } while (atual->getProximo() != sentinela); adicionaNaPosicaoDuplo(data, pos); } }
/*! * \brief Funcao adicionaEmOrdem * \param dado passado por referencia e um tipo generico constante * que representa o dado que entrara na lista. * \return nao possui. * \sa listaVazia(), adicionaNoInicioDuplo(...), maior(...), e * adicionaNaPosicaoDuplo(...) * * Se a lista estiver vazia, entao chama funcao adicionaNoInicioDuplo * para realizar o processo de adicao do dado recebido como * argumento. Caso contrario, entao caminha por todos vertices da * estrutura e para cada um deles compara se a informacao do * vertice e maior do que o dado passado como argumento atraves * da funcao maior, e, tambem verifica se o proximo vertice * existe. Se alguma dessas possibilidade forem verdadeiras, * entao o laco e parado e ira adicionar o dado uma posicao antes * de um elemento maior que ele, ou, no fim da lista, caso o dado * a ser inserido for maior que todos os outros elementos. A * adicao fica por conta da funcao adicionaNaPosicaoDuplo que e * chamada por ultimo. */ void adicionaEmOrdem(const T &data) { if (listaVazia()) { adicionaNoInicioDuplo(data); } else { Elemento<T> *tmpElemento = head; int i = 0; for (; i < size; i++) { if (maior(tmpElemento->getInfo(), data) || tmpElemento->getProximo() == nullptr) break; tmpElemento = tmpElemento->getProximo(); } adicionaNaPosicaoDuplo(data, i); } }
/*! \param dado um elemento a ser retirado do fim da lista \sa adicionaNoInicioDuplo(), adicionaEmOrdemDuplo(), adicionaNaPosicaoDuplo() */ void adicionaDuplo(const T& dado) { adicionaNaPosicaoDuplo(dado, size-1); }
/*! * \brief Funcao adicionaDuplo * \param dado passado por referencia e um tipo generico constante * que representa o dado a ser adicionado na lista. * \return nao possui retorno * \sa listaVazia(), adicionaNoInicioDuplo(...) e * adicionaNaPosicaoDuplo(...) * * Se a lista estiver vazia, entao adiciona no inicio. Caso contrario * adiciona no fim (ultima posicao que corresponde ao size). */ void adicionaDuplo(const T &dado) { if (listaVazia()) adicionaNoInicioDuplo(dado); else adicionaNaPosicaoDuplo(dado, size); }
/** 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 adicionaNaPosicaoDuplo(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". */ virtual void adicionaDuplo(const T& dado) { adicionaNaPosicaoDuplo(dado, size); }