bool gambs_pontoPertence(ListaEnc<Coordenada> pontos, Coordenada obj){
Elemento<Coordenada>* it = pontos.getHead();
for(int i =0; i<pontos.getSize(); i++){
if(igual(it->info->getX(),obj.getX()) && igual(it->info->getY(),obj.getY()))
return true;
it = it->_next;
}
return false;
}
//Obs: não consegui passar parâmetro null para fazer uma única funćão
void insereNoObjeto(ListaEnc<Coordenada>* pontosObjeto, Coordenada ref, Coordenada pontoA){
int pos = 0;
Elemento<Coordenada> *it_lista = pontosObjeto->getHead();
while(!igual(it_lista->info->getX(),ref.getX()) || !igual(it_lista->info->getY(),ref.getY())){//busca como referência o ponto A
it_lista = it_lista->_next;
pos++;
}
pos++;
pontosObjeto->adicionaNaPosicao(pontoA, pos);
}
/**
NOME DA FUNÇÃO: contem
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
retorna 1 se a lista contém um elemento fornecido e 0 em caso contrário.
PARÂMETROS:
nome tipo valor/referência descrição
---------------------------------------------------------------------
dado tAgenda valor elemento a ser procurado
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
-- int 1 caso o contato pertença à lista e 0 em caso contrário
*/
int contem(tAgenda dado) {
int i;
for (i = 0; i <= aLista.ultimo; i++)
if (igual(dado, aLista.elem[i]))
return 1;
return 0;
}
T mostra(int posicao) {
T dado = dados[0];
for(int i = 0; i <= ultimo; i++) {
if (igual(dados[i], dado)) {
return dados[i];
}
}
throw ExcecaoErroPosicao;
}
int posicao(const T& dado) const{
Elemento<T> *aux = head;
for (int j = 0; j < size; j++){
if(igual(*aux->info, dado))
return j;
aux = aux->_next;
}
return -1;
}
/** Verifica se a Lista contêm o elemento especificado.
* @param dado O dado que será verificado a existência dentro da Lista.
* @return um boolean que indica se a Lista contêm ou não o elemento especificado.
*/
bool contem(T dado) {
int igl = 0;
for(int i = 0; i < tamanho; i++) {
if (igual(dados[i], dado)) {
igl = 1;
break;
}
}
return igl == 1;
}
/*!
\return Retorna um ponteiro do tipo T para o dado.
\param dado eh o endereço do dado do tipo T que sera procurado na lista.
*/
T* posicaoMem(const T& dado) const {
Elemento<T>* aux;
aux = head;
for (int controle = 0; controle < size; controle++) {
if (igual(aux->getInfo(), dado))
return aux; // tem diferenca aqui
aux = aux->getProximo();
}
throw(20);
}
/*!
\return Retorna true se o o dado estivar na lista.
\param dado eh o endereço do dado do tipo T a ser verificado.
*/
bool contem(const T& dado) {
Elemento<T> *aux;
aux = head;
for (int controle = 0; controle < size; controle++) {
if (igual(aux->getInfo(), dado))
return true;
aux = aux->getProximo();
}
return false;
}
bool Lista<T>::contem(T dado) {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
for (int i = 0; i <= ultimo; i++) {
if (igual(dado, lista[i])) {
return true;
}
}
return false;
}
int Lista<T>::posicao(T dado) {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
for (int i = 0; i <= ultimo; i++) {
if (igual(dado, lista[i])) {
return i;
}
}
throw ExcecaoDadoNaoEncontrado();
}
//comentário
int posicao(T dado)
{
int pos = 0;
while (pos <= ultimo && !(igual(dado, dados[pos])))
{
pos++;
}
if (pos > ultimo)
throw 20;
return pos;
}
/*
* @brief Metodo pegar a posição de um elemento da Lista
* @details Cria uma variavel auxiliar chamada 'pos', apos isso é feito um laço de repetição que
* verifica se ainda não chegamos ao fim da lista e chama o metodo 'igual' para verificar
* se a posição do parametro 'dado' ja foi encontrada.
* Apos isso é verificado se a posição encontrada é valida, ou seja, se o dado na varival 'pos' é menor ou igual a variavel 'fim'
*/
int posicao(T dado) {
int pos = 0;
while (pos <= fim && !(igual(dado, dados[pos]))) {
pos += 1;
}
if (pos > fim) {
throw(ERROPOSICAO);
} else {
return (pos);
}
}
//comentário
bool contem(T dado)
{
int pos = 0;
while (pos <= ultimo && !(igual(dado, dados[pos])))
{
pos++;
}
if (pos > ultimo)
return false;
return true;
}
/** Verifica se um determinado elemento existe na Lista. Se sim, retorna a sua posição.
* @param dado O dado que será verificado a existência dentro da Lista.
* @exception ExcecaoErroPosicao Exceção que indica que o elemento enviado via argumento não existe dentro dessa Lista.
* @return um int que indica a posição do elemento que foi encontrado na Lista.
*/
int posicao(T dado) {
int i;
for(i = 0; i <= ultimo; i++) {
if (igual(dados[i], dado)) {
break;
}
}
if (i > ultimo) {
throw ExcecaoErroPosicao;
}
return i;
}
/**
* @brief Retorna a posição de um dado específico
*
* @param dado Dado a ser pesquisado
*
* @details Os índices de posição começam em 0 e vão até size-1, ou seja,
* com uma lista de 10 elementos as posições estão numeradas de
* 0 a 9
*/
int posicao(const T& dado) const {
if(listaVazia()) {
throw std::runtime_error("Lista Vazia");
}
Elemento<T> *atual = head;
for(int i = 0; i < size; i++) {
if(igual(dado, atual->getInfo())) {
return i;
}
atual = atual->getProximo();
}
throw std::runtime_error("Este dado não existe");
}
bool ListaEnc<T>::contem(const T& dado) {
if (listaVazia()) {
throw ExcecaoListaVazia();
}
Elemento<T>* atual = cabeca;
for (int i = 0; i < tamanho; i++) {
if (igual(dado, atual->getInfo())) {
return true;
}
atual = atual->getProximo();
}
return false;
}
T* ListaEnc<T>::posicaoMem(const T& dado) const {
if (listaVazia()) {
throw std::runtime_error("Lista Vazia");
} else {
Elemento<T>* aux = head;
for (int i = 0; i < size; ++i) {
if (igual(dado, aux->getInfo())) {
return aux;
}
aux = aux->getProximo();
}
throw std::runtime_error("Não Contém");
}
}
/**
NOME DA FUNÇÃO: obterContatoPeloNome
ALUNOS: Pedro Paulo e Felipe dos Santos
PROPÓSITO:
retorna um contato armazenado que coincida com o nome fornecido, ou um contato
que informa que a posicão é inválida em caso de erro.
PARÂMETROS:
nome tipo valor/referência descrição
---------------------------------------------------------------------
nome char* referência nome a ser procurado
VALOR DE RETORNO:
nome tipo descrição
---------------------------------------------------------------------
contat tAgenda o contato buscado
*/
tAgenda obterContatoPeloNome(char* nome) {
int i;
tAgenda contato;
strcpy(contato.nome, nome);
for (i = 0; i <= aLista.ultimo; i++)
if (igual(contato, aLista.elem[i]))
return aLista.elem[i];
strcpy(contato.nome, "Nome não consta na lista.");
contato.numero = ERRO_POSICAO_INVALIDA;
return contato;
}
/** Verifica a posição de memória de um dado já inserido na Lista.
* Este método recebe um dado que será analisado para verificar se este dado está dentro da Lista.
* @param dado O dado que será verificado a existência dentro da lista.
* @see listaVazia()
* @see igual(const T dado1, const T dado2)
* @exception ExcecaoListaVazia Exceção que indica que a lista está vazia, ou seja, não tem como esse dado existir dentro da Lista Encadeada.
* @exception ExcecaoErroPosicao Exceção que indica que o dado do tipo T fornecido não está presente na lista.
* @return um ponteiro para T que indica a posição de memória em que o dado se encontrava.
*/
T* posicaoMem(const T& dado) const {
if (listaVazia()) {
throw ExcecaoListaVazia;
} else {
Elemento<T> *atual = head;
for (int i = 0; i < size; i++) {
if (igual(atual->getInfo(), dado)) {
return &atual->getInfo();
}
atual = atual->getProximo();
}
}
throw ExcecaoErroPosicao;
}
/**
* @brief Retorna o ponteiro para posição de um dado específico
*
* @param dado Dado a ser pesquisado
*/
T* posicaoMemDuplo(const T& dado) const {
if(listaVazia()) {
throw std::runtime_error("Lista Vazia");
}
ElementoDuplaEnc<T> *atual = head;
for(int i = 0; i < size; i++) {
if(igual(dado, atual->getInfo())) {
return atual;
} else {
atual = atual->getProximo();
}
}
throw std::runtime_error("Este dado não existe");
}
bool ListaEnc<T>::contem(const T& dado) {
if (listaVazia()) {
throw "ErroListaVazia";
} else {
Elemento<T>* aux = head;
for (int i = 0; i < size; ++i) {
if (igual(dado, aux->getInfo())) {
return true;
}
aux = aux->getProximo();
}
return false;
}
}
tree_node_t<T>* tree_t<T>::find(tree_node_t<T>*& root, const T& data) const
{
if (root == NULL)
return root;
else{
if (igual(root->get_data(), data))
return root;
else{
if (menor(data, root->get_data()))
return find(root->get_left(), data);
else
return find(root->get_right(), data);
}
}
}
// especifico
const ElementoGeometrico* ListaElementosGeometricos::retiraEspecifico(const ElementoGeometrico*& dado){
Elemento<const ElementoGeometrico*> *atual = head->getProximo();
Elemento<const ElementoGeometrico*> *proximo;
for(int i = 0; i < size; i++){
if (igual(*atual->getInfo(),dado))
return atual->getInfo();
proximo = atual->getProximo();
atual = proximo;
}
return new ElementoGeometrico(ElementoGeometrico::null);
}
/** Verifica se um determinado elemento existe na Lista. Se sim, retorna a sua posição.
* @param dado O dado que será verificado a existência dentro da Lista.
* @exception ExcecaoErroPosicao Exceção que indica que o elemento enviado via argumento não existe dentro dessa Lista.
* @return um int que indica a posição do elemento que foi encontrado na Lista.
*/
int posicao(T dado) {
int posicao = 0;
for(int i = 0; i <= ultimo; i++) {
if (igual(dados[posicao], dado)) {
break;
} else {
posicao++;
}
}
if (posicao > ultimo) {
throw ExcecaoErroPosicao;
} else {
return posicao;
}
}
bool ListaElementosGeometricos::contem(const ElementoGeometrico*& dado){
Elemento<const ElementoGeometrico*> *atual = head->getProximo();
Elemento<const ElementoGeometrico*> *proximo;
for(int i = 0; i < size; i++){
if (igual(*atual->getInfo(),dado))
return true;
proximo = atual->getProximo();
atual = proximo;
}
return false;
}
/**
* @brief Verifica se a lista contém um dado específico, retornando
* true caso exista um elemento com esse dado
*
* @param dado Dado a ser pesquisado
*/
bool contem(const T& dado) const {
if(listaVazia()) {
return false;
} else {
Elemento<T> *atual = head;
for(int i = 0; i < size; i++) {
if(igual(dado, atual->getInfo())) {
return true;
} else {
atual = atual->getProximo();
}
}
return false;
}
}
/**
* Método que identifica a posição de um objeto da classe ElementoDeLista recebido por parâmetro.
*
* @param elemento = objeto da classe ElementoDeLista.
*
* @return LISTA_VAZIA = constante que informa que não ha elementos na Lista.
* @return ERRO_POSICAO caso o objeto em questão nao esteja na Lista.
* @return posicao = posição onde o ElementoDeLista se encontra na Lista.
*/
int CabecaDeLista::posicao(ElementoDeLista *elemento) {
if (vazia()) {
return LISTA_VAZIA;
}
int posicao = 1;
ElementoDeLista *atual;
atual = primeiro;
while (atual != 0 && !(igual(atual->info, elemento->info))) {
atual = atual->proximo;
posicao++;
}
if (atual == 0) {
return ERRO_POSICAO;
}
return posicao;
}
/*!
* \brief Funcao contemDuplo
* \param dado passado por referencia e um tipo generico constante
* que representa o dado que sera procurado na lista.
* \return um valor booleano que indica se a lista possui ou nao o
* valor passado.
* \sa igual(...)
*
* Caminha por todos vertices da estrutura e para cada um deles
* compara o elemento com o dado passado como argumento atraves
* da funcao igual. Se houver igualdade, entao o laco e parado.
*/
bool contemDuplo(const T &dado) {
Elemento<T> *tmpElemento = head;
while (size != 0) {
if (igual(tmpElemento->getInfo(), dado))
return true;
tmpElemento = tmpElemento->getProximo();
size -= 1;
}
if (size != 0)
delete tmpElemento;
return false;
}
/* Xn = c/cad * [ (1 / (1 - cad)) - 1] */
void inicializa()
{
double r;
int i;
necessario[0] = 0.0;
if(igual(cad, 0.0)){
for(i = 1; i <= voltas; i++)
necessario[i] = necessario[i-1] + c0;
return;
}
r = 1.0;
for(i = 1; i <= voltas; i++){
r /= 1 - cad;
necessario[i] = c0/cad * (r - 1.0);
}
}
int ListaElementosGeometricos::posicao(const ElementoGeometrico*& dado) const{
Elemento<const ElementoGeometrico*> *atual = head->getProximo();
Elemento<const ElementoGeometrico*> *proximo;
for(int i = 0; i < size; i++){
if (igual(*atual->getInfo(), dado))
return i;
proximo = atual->getProximo();
atual = proximo;
}
return -1;
}
