void adicionaNaPosicaoDuplo(const T& dado, int pos) {
//verificar size ou size+1
Elemento2<T> *novo, *anterior;
if (pos > size || pos < 0) {
throw 20;
}
if (pos == 0) {
adicionaNoInicioDuplo(dado);
return;
}
novo = new Elemento2<T>(dado, NULL, NULL);
if (novo == NULL) {
throw 20;
}
anterior = head;
for (int i = 0; i < pos-1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
if (novo->getProximo() != NULL) {
novo->getProximo()->setAnterior(novo);
}
anterior->setProximo(novo);
novo->setAnterior(anterior);
size++;
}
/*
* @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 Funcao adicionaNaPosicaoDuplo
* \param dado passado por referencia e um tipo generico constante
* que representa o dado que ficara na primeira posicao da lista.
* \param pos e um inteiro que indica a posicao em que deve-se
* tentar adicionar o dado.
* \return nao possui.
* \sa adicionaNoInicioDuplo(...)
*
* Se a posicao for valida e ser a zero, chama a funcao
* adicionaNoInicioDuplo para realizar o processo de adicao com o
* dado recebido como argumento. Se a posicao nao for a zero,
* entao istancia um novo Elemento temporario que aponta para um
* nullptr e possui o dado passado como argumento, e, se houver
* espaco na memoria para alocar essa instanciacao, entao caminha
* ate o vertice anterior ao da posicao em que se pretende
* adicionar o dado com outro elemento temporario. Ao chegar
* nessa posicao, aponta o vertice anterior ao primeiro elemento
* temporario criado e aponta esse ultimo para o vertice seguinte
* ao da posicao anterior. Tambem aponta o anterior do elemento
* temporario para o elemento anterior e se o proximo elemento
* apos o temporario existir, ou seja, for diferente de um
* nullptr, aponta o anterior dele para o elemento temporario.
* Por fim, aumenta o numero que indica o tamanho da lista.
*/
void adicionaNaPosicaoDuplo(const T &dado, int pos) {
if (pos > size) {
throw "problema";
} else {
if (pos == 0) {
adicionaNoInicioDuplo(dado);
} else {
Elemento<T> *tmp = new Elemento<T>(dado, nullptr, nullptr);
Elemento<T> *antElemento;
if (tmp == nullptr) {
throw "problema";
} else {
antElemento = head;
while (--pos != 0)
antElemento = antElemento->getProximo();
tmp->setProximo(antElemento->getProximo());
if (tmp->getProximo() != nullptr)
tmp->getProximo()->setBack(tmp);
antElemento->setProximo(tmp);
tmp->setBack(antElemento);
size += 1;
}
}
}
}
/**
* @brief Adiciona um elemento na posição desejada
*
* @param dado O valor dado como parâmetro cria um novo objeto da
* classe ElementoDuplaEnc, dado = info (ver classe
* ElementoDuplaEnc.hpp)
* @param pos Posição desejada para o elemento ser colocado
*
* @details Caso a posição seja 0 chama o método adicionaNoInicioDuplo(),
* pois é um caso epecífico Uma explicação de como é feito os
* índices de posição desta lista podem ser encontrada na
* descrição do método posicaoDuplo()
*/
void adicionaNaPosicaoDuplo(const T& dado, int pos) {
if(pos > size || pos < 0) {
throw std::runtime_error("Posição Inválida");
}
if(pos == 0) {
adicionaNoInicioDuplo(dado);
} else {
ElementoDuplaEnc<T> *atual = head;
ElementoDuplaEnc<T> *novo =
new ElementoDuplaEnc<T>(dado, nullptr, nullptr);
if(novo == nullptr) {
throw std::runtime_error("Sem Espaço na Memória");
} else {
for(int i = 0; i < (pos-1); i++) {
atual = atual->getProximo();
}
novo->setProximo(atual->getProximo());
atual->getProximo()->setAnterior(novo);
novo->setAnterior(atual);
atual->setProximo(novo);
++size;
}
}
}
/*!
\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);
}
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 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);
}
}
/*
* @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));
}
}
}
/*
* @brief Metodo adicionaNaPosicaoDuplo
* @details Metodo para adicionar em uma posição especifica
* @param O parametro 'dado' é o dado a ser alocado em determinada posição
* @poram O parametro 'pos' é a posição que o dado será adicionado
* Verifica se a posição é valida
* Verifica se a posição é '0', caso seja, chama o metodo adicionaNoInicio e passa como parametro 'dado'
* Cria dois ponteiros auxiliares chamados 'novo' e 'anterior'
*/
void adicionaNaPosicaoDuplo(const T& dado, int pos) {
if (pos < 0 || pos > tamanho) {
throw("ERRO DE POSICAO");
} else if (pos == 0) {
adicionaNoInicioDuplo(dado);
} else {
ElementoDuplo<T> *novo, *anterior;
novo = sentinela->getProximo();
int posi = 0;
while (posi < pos-1) {
novo = novo->getProximo();
posi += 1;
}
anterior = novo->getProximo();
novo->getProximo()->setAnterior(novo);
novo->setProximo(new ElementoDuplo<T>(dado, anterior, novo));
tamanho += 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 dado um elemento a ser inserido
\param pos a posicao onde o dado vai ser inserido
\sa adicionaDuplo(), adicionaNoInicioDuplo(), adicionaEmOrdemDuplo()
*/
void adicionaNaPosicaoDuplo(const T& dado, int pos) {
ElementoDuplo<T> *novo = new ElementoDuplo<T> (dado, head, NULL);
ElementoDuplo<T> *anterior = head->getProximo();
if (novo == NULL) {
throw "posição inválida";
}
if (pos > size-1 || pos < 0) {
throw "posição inválida";
}
if (pos == 0) {
return adicionaNoInicioDuplo(dado);
}
for (int i = 0; i < pos-1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
novo->getProximo()->setAnterior(novo);
anterior->setProximo(novo);
novo->setAnterior(anterior);
size++;
}
/** 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);
}
}
}
/** Adiciona um novo elemento na posição dada.
* 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(dado);
*/
virtual void adicionaNaPosicaoDuplo(const T& dado, int pos) {
verificaMemoriaCheia();
ElementoDuplo<T>* novo = new ElementoDuplo<T>(dado, NULL, NULL);
ElementoDuplo<T>* anterior;
if (pos > size || pos < 0) {
throw ExcecaoErroPosicao;
}
if (pos == 0) {
adicionaNoInicioDuplo(dado);
} else {
anterior = head;
for (int i = 0; i < pos - 1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
if (novo->getProximo() != NULL) {
(novo->getProximo())->setAnterior(novo);
}
novo->setAnterior(anterior);
anterior->setProximo(novo);
size++;
}
}
void ListaDupla<T>::adicionaNaPosicaoDuplo(const T& dado, int pos) {
if (posicaoInvalida(pos)) {
throw ExcecaoPosicao();
}
if (pos == 0) {
adicionaNoInicioDuplo(dado);
return;
}
ElementoDuplo<T>* anterior = cabeca;
ElementoDuplo<T>* novo = new ElementoDuplo<T>(dado, 0, 0);
if (novo == 0) {
throw ExcecaoListaCheia();
}
for (int i = 0; i < pos - 1; i++) {
anterior = anterior->getProximo();
}
novo->setProximo(anterior->getProximo());
if(novo->getProximo() != 0) {
novo->getProximo()->setAnterior(novo);
}
anterior->setProximo(novo);
anterior->getProximo()->setAnterior(anterior);
tamanho++;
}
/*!
* \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);
}
