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