nicholas22

@arfneto Eu declarei da forma que o professor declarou todas as listas que ele fez... Ainda não entendi porque essa última lista que eu fiz está errada pois ela roda e mostra certinho a lista normal e a inversa. A única coisa que dá errado é que ela só mostra número inteiro. Vou tentar declarar como você falou.

@arfneto po cara valeu mesmo por tentar me ajudar nessa questão, eu vou desistir dela, tenho que entregar essa questão e mais 3 exercícios que não sei fazer até até as 6 da manhã, além de que eu realmente não sei mais o que fazer pra essa questão dar certo.Ter aula com ead e dizer quais são as dúvidas de maneira escrita é muito complicado pra mim eu literalmente aprendi muito pouco dessa matéria nesse semestre e meu professor quer as coisas sempre do jeito dele o que acaba dificultado muito pois se eu modifico uma coisinha se quer ele já tira quase todo o ponto. Mas enfim , obrigado de verdade e desculpa por fazer você perder seu tempo.

@arfneto Sim, foi o professor que escreveu o código anterior. Essa função que eu fiz antes eu tinha visto um exemplo na internet e tentei fazer no mesmo estilo só que não deu certo.Eu entendo o que o senhor fala porém mas quando eu vou fazer parece que dá um nó na minha mente e eu me enrolo kkk. Eu fiz um outro código usando o inserir no fim como você mostrou e parece que deu meio certo pois ele não dá erro no compilador mas quando coloco um elemento do tipo float no main só aparece como se fosse inteiro. #include<stdio.h> #include<stdlib.h> struct TLDE { int dados; struct TLDE* prox; }; TLDE* inserir_no_fim( TLDE*p , float elem) { TLDE *raiz = p; TLDE* pTemp = (struct TLDE*)malloc(sizeof(struct TLDE*)); pTemp->dados = elem; pTemp->prox = NULL; if(!raiz) return pTemp; else { TLDE* pPar = p; while(p->prox) { p=p->prox; } p->prox =pTemp; return raiz; } } void exibir(TLDE* p) { if(!p) printf("Lista vazia"); else { do { printf(" %d", p->dados); p=p->prox; } while(p); } } TLDE * inverte( TLDE *l) { TLDE*r =NULL; // r é o ponteiro para a lista invertida TLDE*s =NULL; //s é o ponteiro para o ultimo elemento da lista invertida while(l) { s=r; r=l; l=l->prox; r->prox=s; } return r; } int main() { TLDE *inicializa =NULL; inicializa = inserir_no_fim(inicializa,1056985466); inicializa = inserir_no_fim(inicializa,9); inicializa = inserir_no_fim(inicializa,6.5); inicializa = inserir_no_fim(inicializa,4.5); printf("\nLista normal: "); exibir(inicializa); inicializa = inverte(inicializa); printf("\nLista invertida: "); exibir(inicializa); }

Alguém me da uma luz pf preciso entregar amanhã @herbertbahia Moço, você saberia me explicar?

@arfneto Eu consegui fazer usando ponteiro de ponteiro porém meu professor falou que só ia aceitar com um ponteiro. Tem como mudar pra ficar com um só nas funções insere e inverte? #include <iostream> using namespace std; struct TLDE { int dados; struct TLDE *ant, *prox; }; TLDE* novaLista(int val){ TLDE* temp = new TLDE; temp->dados = val; temp->ant = temp->prox = NULL; return temp; } void exibir(TLDE* l){ while (l->prox != NULL) { cout << l->dados << " ---- "; l = l->prox; } cout << l->dados << endl; } TLDE *insere(TLDE** l, int elem){ TLDE* temp = novaLista(elem); temp->prox = *l; (*l)->ant = temp; (*l) = temp; } TLDE *inverte(TLDE** l){ TLDE* esquerda = *l, * direita = *l; while (direita->prox != NULL) direita = direita->prox; while (esquerda != direita && esquerda->ant != direita) { swap(esquerda->dados, direita->dados); esquerda = esquerda->prox; direita = direita->ant; } } int main() { TLDE* no_principal = novaLista(201698546); insere(&no_principal, 6.9); insere(&no_principal, 9.6); insere(&no_principal, 2); cout << "Lista original: " << endl; exibir(no_principal); cout << "Lista inversa: " << endl; inverte(&no_principal); exibir(no_principal); return 0; }

@arfneto Na verdade é um exercício de a, b e c cujo o enunciado é: Um determinado professor deseja criar um programa para armazenar as notas dos alunos de suas turmas. Basicamente, cada aluno possui matrícula e três notas como exemplificado na tabela abaixo. Matricula A1 A2 A3 20170123456 10,0 10,0 10,0 20160223456 9,0 8,0 7,0 Considere uma lista duplamente encadeada que armazena os seguintes dados de alunos de uma disciplina: - Matrícula: número inteiro - A1: Número de ponto flutuante - A2: Número de ponto flutuante - A3: Número de ponto flutuante a)Escreva uma função RECURSIVA que, dadas duas listas de alunos duplamente encadeadas l1 e l2, verifique se as mesmas são iguais. As listas l1 e l2 devem permanecer inalteradas. Esta função retorna 1 se as listas são iguais e 0, caso contrário. O protótipo desta função é o seguinte: int igual_recursivo (TLDE *l1, TLDE *l2) Essa eu já fiz e a resposta é: #include<stdlib.h> #include<stdio.h> typedef struct lista{ int matricula; float a1,a2,a3; struct lista *prox; struct lista *ant; }TLDE; int igual_recursivo (TLDE *l1, TLDE *l2){ if(l1==NULL &&l2==NULL){ return 1; } if(l1==NULL || l2==NULL){ return 0; } if(l1!=NULL && l2!=NULL){ if((l1->a1==l2->a1)&&(l1->a2==l2->a2)&&(l1->a3==l2->a3)&&(l1->matricula==l2->matricula)){ return igual_recursivo (l1->prox,l2->prox); } else{ return 0; } } else{ return 0; } } b)Escreva uma função que, dada uma lista duplamente encadeada l de alunos, inverta os elementos de l em uma outra lista duplamente encadeada de saída. Portanto, a lista de entrada não pode ser alterada. O protótipo da função de inversão é o seguinte: TLDE* inverte (TLDE* l);

@arfneto eu tentei primeiro criar uma lista mas acho que fiz besteira pois não sei como fazer para mostrar as notas já que na função insere o x só aceita int. E eu acho que fica melhor se colocar as notas como vetor só que eu to um pouco confuso com isso #include <stdlib.h> #include<stdio.h> typedef struct lista { int matricula ; float vetor[3]; struct lista* prox; struct lista *ant; }TLista; TLista* inicializa() { return NULL; } TLista* insere(TLista* l, int x){ float a; TLista* novo = (TLista*) malloc(sizeof(TLista)); novo->matricula = x; novo->vetor[3]=a; novo->prox = l; return novo; } TLista* retira(TLista* l, int x){ TLista *ant=NULL, *p=l, *p2=l; int a; while((p != NULL) && (p->matricula!= x)){ ant = p; p = p->prox; } if(!p){ return l; } if(!ant){ l = l->prox; }else{ ant->prox = p->prox; } free(p); return l; while((p2 != NULL) && (p2->vetor[3]!= a)){ ant = p2; p2 = p2->prox; } if(!p2){ return l; } if(!ant){ l = l->prox; }else{ ant->prox = p2->prox; } free(p2); return l; } int vazia(TLista *l){ if(l == NULL) return 1; else return 0; } void libera(TLista *l){ TLista *p = l; TLista *aux; while(p != NULL){ aux = p; p = p->prox; free(aux); } } void imprime(TLista* l){ TLista* p; for (p = l; p != NULL; p = p->prox){ printf("matricula = %d\n", p->matricula); } TLista* p2; for (p2 = l; p2 != NULL; p2 = p2->prox){ printf("notas = %d\n", p2->vetor[3]); } } int main(){ TLista *l; l = inicializa(); l = insere(l, 10565644); l = insere(l, 208646465); l = insere(l, 30445465); l = insere(l, 404468546); imprime(l); }

@arfneto Desse jeito? TLDE* inverte (TLDE* l){ TLDE* aux, *ant, *prox; if(l == NULL) return NULL; while(l != NULL){ ant = l; aux = l->prox; l->prox = l->ant; l->ant = aux; l=aux; } return ant; } o que eu faço com a matricula e as notas?

@arfneto Realmente, dá forma que você falou seria muito melhor porém infelizmente tenho que fazer como o professor quer kkkk. Eu consegui fazer aqui obrigadoo adicionado 3 minutos depois @herbertbahia obrigadoo

Ajuda nessa questão aqui pf Escreva uma função que, dada uma lista duplamente encadeada l de alunos, inverta os elementos de l em uma outra lista duplamente encadeada de saída. Portanto, a lista de entrada não pode ser alterada. O protótipo da função de inversão é o seguinte: TLDE* inverte (TLDE* l); A questão dá apenas isso: typedef struct lista{ int matricula; float a1,a2,a3; struct lista *prox; struct lista *ant; }TLDE; E qual a diferença de uma lista encadeada para uma duplamente encadeada?

@arfneto não entendi direito, como eu crio um vetor com eles em ordem? isso ficaria na função?

Alguém me ajuda por favor Não posso alterar o código já pronto. Preciso implementar no código abaixo uma função que, dada uma fila de entrada p, retorne uma fila com todos os elementos de p ordenados de maneira crescente. Ao final da execução desta função, p permanecerá com todos os seus elementos. O protótipo desta função é o seguinte: TFila* ordena (TFila *f) #include <stdlib.h> typedef struct lista{ int info; struct lista *prox; }TLista; typedef struct fila{ TLista *ini; TLista *fim; }TFila; TFila* inicializa(){ TFila *f = (TFila*) malloc(sizeof(TFila)); f->ini = f->fim = NULL; return f; } int vazia(TFila *f){ if(f->ini == NULL) return 1; else return 0; } void insere(TFila *f, int elem){ TLista *novo = (TLista*)malloc(sizeof(TLista)); novo->info = elem; novo->prox = NULL; if(f->fim){ f->fim->prox = novo; } f->fim = novo; if(!f->ini){ f->ini = novo; } } int retira(TFila *f){ if(vazia(f)) return; int elem = f->ini->info; TLista *aux = f->ini; f->ini = f->ini->prox; if(f->ini == NULL){ f->fim = NULL; } free(aux); return elem; } void libera(TFila *f){ TLista *q = f->ini; TLista *aux; while(q){ aux = q; q = q->prox; free(aux); } free(f); }

os ponteiros permitem a modificação dos valores das variáveis através da referência ao endereço de memória da variável?

@Mauro Britivaldo eu não sei como faço pra separar as filas

@herbertbahia mas como eu faço pra percorrer? Não precisa saber o tamanho?

adicionado 44 minutos depois @herbertbahia moço eu criei uma fila pra ficar mais fácil. Como eu faço a função soma usando ela?

Alguém me ajuda pf typedef struct fila TFila; TFila* inicializa (void); TFila* insere (TFila *f, int elem); int retira (TFila *f); void libera (TFila *f); int vazia (TFila *f); #include <stdlib.h> typedef struct lista{ int info; struct lista *prox; }TLista; typedef struct fila{ TLista *ini; TLista *fim; }TFila; TFila* inicializa(){ TFila *f = (TFila*) malloc(sizeof(TFila)); f->ini = f->fim = NULL; return f; } int vazia(TFila *f){ if(f->ini == NULL) return 1; else return 0; } void insere(TFila *f, int elem){ TLista *novo = (TLista*)malloc(sizeof(TLista)); novo->info = elem; novo->prox = NULL; if(f->fim){ f->fim->prox = novo; } f->fim = novo; if(!f->ini){ f->ini = novo; } } int retira(TFila *f){ if(vazia(f)) return; int elem = f->ini->info; TLista *aux = f->ini; f->ini = f->ini->prox; if(f->ini == NULL){ f->fim = NULL; } free(aux); return elem; } void libera(TFila *f){ TLista *q = f->ini; TLista *aux; while(q){ aux = q; q = q->prox; free(aux); } free(f); } Usando as funções definidas acima implemente uma função que receba três filas, f, impares e pares (todas já inicializadas), e separe todos os valores guardados em f de tal forma que os valores pares são colocados na fila pares e os valores ímpares na ímpares. Ao final da execução desta função, f permanecerá com todos os seus elementos. É obrigatório o uso do protótipo: void separa_filas(TFila* f, TFila* par, TFila* impar)

No exercício que eu estou fazendo pede pra imaginar que existe uma fila, tipo ele n pede pra fazer a fila em si, ele pede só pra criar uma função que some os elementos positivos dessa suposta fila

Alguém ajuda nesse exercício pf Considerando uma lista duplamente encadeada que armazena os dados de um aluno: - Número de Matrícula: número inteiro - Nota1: Número de ponto flutuante - Nota2: Número de ponto flutuante - Nota3: Número de ponto flutuante Escreva uma função RECURSIVA que, dada uma lista duplamente encadeada l de alunos, desloque uma vez os elementos de l, de acordo com n. Se n é par, o elemento que está na última posição passa a ser o primeiro quando a lista é deslocada. Senão, o elemento que está na primeira posição passa a ser o último. É obrigatório o uso do protótipo: TLDE* desloca (TLDE* l, int n) Não precisa escrever as listas, precisa apenas da função desloca.

Alguém ajuda nesse exercício por favor Considerando uma lista duplamente encadeada que armazena os dados de um aluno numa matéria : - Matrícula: número inteiro - Nota1: Número de ponto flutuante - Nota2: Número de ponto flutuante - Nota3: Número de ponto flutuante Escreva uma função RECURSIVA que, dadas duas listas de alunos duplamente encadeadas l1 e l2, verifique se as mesmas são iguais. As listas l1 e l2 devem permanecer inalteradas. Esta função retorna 1 se as listas são iguais e 0, caso contrário. É obrigatório o uso do protótipo: int igualRecursivo (TLDE *l1, TLDE *l2) Não precisa escrever as listas, precisa apenas da função que verifica se são iguais

Alguém ajuda nesse exercício pf Leve em consideração a existência de um tipo abstrato fila de números inteiros, cuja a interface é definida no arquivo fila.h da seguinte forma: typedef struct fila TFila; TFila* inicializa (void); TFila* insere (TFila *f, int elem); int retira (TFila *f); void libera (TFila *f); int vazia (TFila *f); Usando as funções definidas em fila.h implemente uma função que receba uma fila f, e some todos os valores positivos guardados em f. Ao final da execução desta função, f permanecerá com todos os seus elementos e retorna-se a soma. int somaPositivo(TFila *f) Não precisa criar a fila, precisa apenas da função que soma os elementos.