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