NhemonF

Então nesta linha aqui: int (*f[4]) (No*, Produto*); Devo escrever nest maneira? int (*f[2]) (No*, Produto*) = { f_crescente, f_decrescente } =================================================================== Não havia entendido esta parte, porque ao ler o codigo que você escreveu, eu fiquei me perguntando sobre isso. =================================================================== Como assim escrever em torno dos dados? =================================================================== Aqui, não aconteceu nada :// Estou tentando, agora, fazer de outra forma: Pensei agr em colocar um [switch...case] para isso. Mas, ao mesmo tempo, estou colocando as funções que você escreveu E, claro, as modificações feitas no código. Só que vou precisar de um tempo para pensar em como aplicá-lo.

Só não entendi de onde veio o "antes"... Da onde ele veio? Vou escrever o que você escreveu, se importar. E o que eu imaginei. Mas por enquanto em ordem crescente: Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO //Estou pensando em como fazer if (listaEstaVazia(L)) { return; } else { Lista *Crescente = criaLista(); No *destino = Crescente->inicio; No *origem = L->inicio; int (*f[4]) (No*, Produto*); while (f[ordem] (destino, origem->prod) > 0) { No *antes = destino; insereNoInicio(Crescente, destino->prod->num_serie, destino->prod->preco, destino->prod->nome); destino = destino->prox; } } } int f_crescente(No* no_na_lista, Produto* novo) { if (novo == NULL) return 1; // nao esperado if (no_na_lista == NULL) { return -1; // acabou }; return no_na_lista->prod->num_serie < novo->num_serie; // aqui }

Bom... quer dizer então que devo, basicamente, escrever uma Bubble Sort para ordenar de forma decrescente ou crescente? Porque, pelo que entendi em outros fóruns e outros artigos que busquei ver, a função irá percorrer todo a lista simples encadeada, e verificar se o num_serie é menor que o outro.

@arfneto Acho que pra ficar melhor, vou colar o código com as alterações. /*************************** * LAB 04 - 02/12/2020 * SEU NOME - SEU PRONTUÁRIO ***************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> // struct que define um produto typedef struct _produto { int num_serie; // numero de série do produto char nome[64]; double preco; } Produto; // struct que define um nó curcular duplamente encadeado typedef struct _no { Produto *prod; struct _no *prox; } No; // struct que define uma Lista Ligada Simples typedef struct _lista { No *inicio; No *fim; int tamanho; // numero de nós da lista } Lista; typedef struct { No *inicio; No *fim; No* i_crescente; No* f_crescente; No* i_decrescente; No* f_decrescente; int tamanho; } Lista1; typedef struct { No *inicio; No *fim; No* H[3]; // head 0 cronologico No* T[3]; // tail 1 cresc 2 decresc int tamanho; } Lista2; /*********** HEADERS ***********/ Produto *criaProduto(int num_serie, double preco, char nome[64]); void destroiProduto(Produto **prod_ref); No *criaNo(int num_serie, double preco, char nome[64]); Lista *criaLista(); void destroiLista(Lista **L_ref); int listaEstaVazia(const Lista *L); void imprime(const Lista *L); void imprime_ultimo(const Lista *L); // A SEREM IMPLEMENTADAS POR VOCÊ void insereNoInicio(Lista *L, int num_serie, double preco, char nome[64]); void removeProduto(Lista *L, int num_serie); void removePrimeiraMetade(Lista *L); Lista *inverter(const Lista *L); Lista *ordenar(const Lista *L, int ordem); /*******************************/ int main() { Lista *L = criaLista(); char comando[64]; int ordem; int num_serie; char nome[64]; double preco; scanf("%s", comando); while (strcmp(comando, "para") != 0) { if (strcmp(comando, "insere_inicio") == 0) { scanf("%d", &num_serie); scanf("%lf", &preco); scanf(" %[^\t\n]s", nome); insereNoInicio(L, num_serie, preco, nome); } else if (strcmp(comando, "remove_produto") == 0) { scanf("%d", &num_serie); removeProduto(L, num_serie); } else if (strcmp(comando, "remove_primeira_metade") == 0) { removePrimeiraMetade(L); } else if (strcmp(comando, "inverte") == 0) { Lista *L_aux = inverter(L); destroiLista(&L); L = L_aux; } else if (strcmp(comando, "ordena") == 0) { scanf("%d", &ordem); Lista *L_aux = ordenar(L, ordem); destroiLista(&L); L = L_aux; } else if (strcmp(comando, "imprime") == 0) { imprime(L); } scanf("%s", comando); } return 0; } //////////////////////////////////// /*************** BODIES *****************/ // (a) Insere um nó no início da Lista com um novo produto, que possui os valores passados por parâmetro. void insereNoInicio(Lista *L, int num_serie, double preco, char nome[64]) { // IMPLEMENTE ESTA FUNÇÃO No *p = criaNo(num_serie, preco, nome); //Cria um nó de um produto para inserir os dados p->prox = L->inicio; //Aponta a partir do início da lista encadeada L->inicio = p; //Coloca os dados do produto pro início L->tamanho++; //Aumenta o tamanho da lista para cada produto adicionado no encadeamento. if (L->fim == NULL) { L->fim = p; } } // (b) Remove o nó da lista cujo produto possua o número de série num_serie. // Assuma que o número de série é único na lista. // Se a lista estiver vazia ou não existir nenhum produto com o número de série, nada acontece. void removeProduto(Lista *L, int num_serie) { // IMPLEMENTE ESTA FUNÇÃO //caso a lista esteja vazia if (listaEstaVazia(L)) { return; } //variável que indica se o número de serie foi encontrado ou não // 0 para não // 1 para sim int encontrou = 0; //verifica se o número encontrado está no início if(L->inicio->prod->num_serie == num_serie) { L->inicio = L->inicio->prox; encontrou = 1; L->tamanho--; } //verifica se o número encontrado está em qualquer posição else { No *no = L->inicio; No *anterior = NULL; //percorre todo o nó da lista para encontrar o valor inserido while(no != NULL && encontrou == 0) { if(no->prod->num_serie == num_serie) { anterior->prox = no->prox; encontrou = 1; L->tamanho--; } anterior = no; no = no->prox; } } } // (c) Remove a primeira metade da Lista. Caso a lista possua um número ímpar de elementos, // considere que a primeira metade possui mais elementos // (Ex: se a lista possuir 5 elementos, a primeira metade possui os 3 primeiros elementos). // Se a lista tiver vazia, nada acontece. void removePrimeiraMetade(Lista *L) { // IMPLEMENTE ESTA FUNÇÃO //Estou pensando no código } // (d) Retorna a Lista invertida. Se a lista está vazia, retorne uma lista vazia. Lista *inverter(const Lista *L) { // IMPLEMENTE ESTA FUNÇÃO if (L == NULL) return NULL; No* p = L->inicio; Lista* Outra = criaLista(); if (Outra == NULL) return NULL; while (p != NULL) { insereNoInicio(Outra, p->prod->num_serie, p->prod->preco, p->prod->nome); p = p->prox; }; // while() return Outra; return NULL; } // (e) Retorna a lista ordenada pelo número de série de seus produtos, de acordo com uma ordem passada pelo programa: // ordem=0 significa ordem crescente; // ordem=1 significa ordem decrescente. Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO if (listaEstaVazia(L)) { return NULL; } else { if (ordem == 0){ Lista *Crescente = criaLista(); No *p = L->inicio; int menor = p->prod->num_serie; while(p != NULL){ if (menor < p->prod->num_serie){ } p = p->prox; } return Crescente; } else { Lista *Decrescente = criaLista(); No *p = L->inicio; int maior = p->prod->num_serie; while (p != NULL){ if (maior > p->prod->num_serie){ } p = p->prox; } return Decrescente; } } } int f_crescente( Produto* um, Produto* outro) { return um->num_serie < outro->num_serie; } int f_decrescente( Produto* um, Produto* outro) { return um->num_serie > outro->num_serie; } /************ FUNÇÕES JÁ IMPLEMENTADAS *************/ Produto *criaProduto(int num_serie, double preco, char nome[64]) { Produto *prod = (Produto *)calloc(1, sizeof(Produto)); prod->num_serie = num_serie; prod->preco = preco; strcpy(prod->nome, nome); return prod; } void destroiProduto(Produto **prod_ref) { Produto *prod = *prod_ref; if (prod != NULL) { free(prod); *prod_ref = NULL; } } No *criaNo(int num_serie, double preco, char nome[64]) { No *no = (No*) calloc(1, sizeof(No)); no->prod = criaProduto(num_serie, preco, nome); no->prox = NULL; return no; } Lista *criaLista() { return ((Lista*) calloc(1, sizeof(Lista))); } void destroiLista(Lista **L) { Lista *L_aux = *L; // remove todos os nós da lista No *p = L_aux->inicio; while (p != NULL) { No *no = p; p = p->prox; destroiProduto(&no->prod); free(no); } free(L_aux); *L = NULL; } int listaEstaVazia(const Lista *L) { return (L->inicio == NULL); } void imprime(const Lista *L) { printf("Tamanho da lista: %d\n", L->tamanho); printf("L -> "); if (!listaEstaVazia(L)) { No *p = L->inicio; while (p != NULL) { printf("(%d, %.2lf, %s) -> ", p->prod->num_serie, p->prod->preco, p->prod->nome); p = p->prox; } } printf("NULL\n\n"); }

Eu li, mas não entendi muito bem o que você disse. Eu devo criar estas funções dentro ou fora da função que havia feito?

@arfneto Então, sobre isso, alterei o código da função. Então ficou mais ou menos assim? Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO if (listaEstaVazia(L)) { return NULL; } else { if (ordem == 0){ Lista *Crescente = criaLista(); No *p = L->inicio; int menor = p->prod->num_serie; while(p != NULL){ if (menor < p->prod->num_serie){ insereNoInicio(Crescente, p->prod->num_serie, p->prod->preco, p->prod->nome); } p = p->prox; } return Crescente; } else { Lista *Decrescente = criaLista(); No *p = L->inicio; int maior = p->prod->num_serie; while (p != NULL){ if (maior > p->prod->num_serie){ insereNoInicio(Decrescente, p->prod->num_serie, p->prod->preco, p->prod->nome); } p = p->prox; } return Decrescente; } } } Só que desta vez, ele apaga os menores números de série. E sobram apenas os maiores números.

Olá pessoal, Estou com um problema no meu código. Ao invés de ordenar a lista prlo número de série do item, ele apaga o menor dado. Alguém pode me ajudar com este problema? Função do exercício que estou com problema // (e) Retorna a lista ordenada pelo número de série de seus produtos, de acordo com uma ordem passada pelo programa: // ordem=0 significa ordem crescente; // ordem=1 significa ordem decrescente. Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO if (listaEstaVazia(L)) { return NULL; } else { if (ordem == 0){ Lista *Crescente = criaLista(); No *p = L->inicio; int menor = p->prod->num_serie; while(p != NULL){ if (menor < p->prod->num_serie){ insereNoInicio(Crescente, p->prod->num_serie, p->prod->preco, p->prod->nome); } p = p->prox; } return Crescente; } else { Lista *Decrescente = criaLista(); No *p = L->inicio; int maior = p->prod->num_serie; while (p != NULL){ if (maior > p->prod->num_serie){ insereNoInicio(Decrescente, p->prod->num_serie, p->prod->preco, p->prod->nome); } p = p->prox; } return Decrescente; } } }

Boa tarde (ou boa noite), pessoal!! Estou ainda com uma dúvida referente ao exercício da faculdade que estou a fazer. O exercício consiste em um objetivo: queria ordenar de maneira crescente e decrescente uma lista ordenada pelo serial de um produto. Por exemplo: 1. Output da lista exemplo L -> (324, 899.99, playstation 5) -> (892, 399.99, mouse gamer) -> (435, 199.99, headset gamer) -> NULL 2. Output da lista em ordem crescente L -> (324, 899.99, playstation 5) -> (435, 199.99, headset gamer) -> (892, 399.99, mouse gamer) -> NULL 3. Output da lista em ordem decrescente L -> (892, 399.99, mouse gamer) -> (435, 199.99, headset gamer) -> (324, 899.99, playstation 5) -> NULL Só que não tenho certeza se fiz da forma certa esta função que fiz. Poderiam me dar uma ajuda neste código? Alguns itens que estou utilizando na composição do código: A. Função que ordena a lista, sendo crescente ou decrescente: // (e) Retorna a lista ordenada pelo número de série de seus produtos, de acordo com uma ordem passada pelo programa: // ordem=0 significa ordem crescente; // ordem=1 significa ordem decrescente. Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO //Estou pensando em como fazer if (ordem == 0){ Lista *Crescente = criaLista(); No *p; No *menor = p->prod->num_serie; if (listaEstaVazia(L)){return -1;} if (listaEstaVazia(Crescente)){return -1;} while(p != NULL){ insereNoInicio(Crescente, p->prod->num_serie, p->prod->preco, p->prod->nome); p = p->prox; } return Crescente; } else { Lista *Decrescente = criaLista(); No *p; No *maior = p->prod->num_serie; if (listaEstaVazia(L)){return -1;} if (listaEstaVazia(Decrescente)) {return -1;} while (p != NULL){ insereNoInicio(Decrescente, p->prod->num_serie, p->prod->preco, p->prod->nome); p = p->prox; } return Decrescente; } } B. Structs 'no', 'lista' e 'produto': // struct que define um produto typedef struct _produto { int num_serie; // numero de série do produto char nome[64]; double preco; } Produto; // struct que define um nó curcular duplamente encadeado typedef struct _no { Produto *prod; struct _no *prox; } No; // struct que define uma Lista Ligada Simples typedef struct _lista { No *inicio; No *fim; int tamanho; // numero de nós da lista } Lista; C. Função inserida na main para execução: else if (strcmp(comando, "ordena") == 0) { scanf("%d", &ordem); Lista *L_aux = ordenar(L, ordem); destroiLista(&L); L = L_aux; }

@arfneto Ok!! Agradeço demais!!

@arfneto Aproveitando esta deixa, poderia me ajudar um pouco mais no programa? Eu sei que estou tomando muito do seu tempo, mas estou com dúvidas a respeito deste programa Bom, agora pra ordenar de forma crescente e decrescente, de acordo com o número de série do produto, devo criar um ponteiro chamado "crescente", que seria o ponteiro de Lista e igualar a L. Certo? E depois criar o nó *p, que vai apontar para o produto, e que por sua vez vai apontar para o número de série? Como no código abaixo: Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO //Estou pensando em como fazer if (ordem == 0){ Lista *Crescente = L; No *p = p->prod->num_serie; while (p != NULL){ insereNoInicio(Crescente, p->prod->num_serie, p->prod->preco, p->prod->nome); p->prod->num_serie = p->prox; } } }

@arfneto Queria agradecer pela ajuda e pelo tempo que você teve para me ajudar neste exercício. Desculpe pela minha lerdeza em pensar (que faz jus à foto do perfil)

@arfneto Ah!! Desculpe. Vou ler aqui Agora entendi!! Pelo que vi no seu código e o que eu escrevi bem no início do post, vi que equivoquei bastante em tentar inverter a ordem, como se fosse uma lista duplamente encadeada. Tentei fazer esta possibilidade de uma lista simplesmente encadeada se tornar duplamente encadeada pelo método que fiz Agora esclareceu bastante!!!

**mensagem apagada**

@arfneto Vou postar o código aqui mesmo. /*************************** * LAB 04 - 02/12/2020 * SEU NOME - SEU PRONTUÁRIO ***************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> // struct que define um produto typedef struct _produto { int num_serie; // numero de série do produto char nome[64]; double preco; } Produto; // struct que define um nó curcular duplamente encadeado typedef struct _no { Produto *prod; struct _no *prox; } No; // struct que define uma Lista Ligada Simples typedef struct _lista { No *inicio; No *fim; int tamanho; // numero de nós da lista } Lista; /*********** HEADERS ***********/ Produto *criaProduto(int num_serie, double preco, char nome[64]); void destroiProduto(Produto **prod_ref); No *criaNo(int num_serie, double preco, char nome[64]); Lista *criaLista(); void destroiLista(Lista **L_ref); int listaEstaVazia(const Lista *L); void imprime(const Lista *L); void imprime_ultimo(const Lista *L); // A SEREM IMPLEMENTADAS POR VOCÊ void insereNoInicio(Lista *L, int num_serie, double preco, char nome[64]); void removeProduto(Lista *L, int num_serie); void removePrimeiraMetade(Lista *L); Lista *inverter(const Lista *L); Lista *ordenar(const Lista *L, int ordem); /*******************************/ int main() { Lista *L = criaLista(); char comando[64]; int ordem; int num_serie; char nome[64]; double preco; scanf("%s", comando); while (strcmp(comando, "para") != 0) { if (strcmp(comando, "insere_inicio") == 0) { scanf("%d", &num_serie); scanf("%lf", &preco); scanf(" %[^\t\n]s", nome); insereNoInicio(L, num_serie, preco, nome); } else if (strcmp(comando, "remove_produto") == 0) { scanf("%d", &num_serie); removeProduto(L, num_serie); } else if (strcmp(comando, "remove_primeira_metade") == 0) { removePrimeiraMetade(L); } else if (strcmp(comando, "inverte") == 0) { Lista *L_aux = inverter(L); destroiLista(&L); L = L_aux; } else if (strcmp(comando, "ordena") == 0) { scanf("%d", &ordem); Lista *L_aux = ordenar(L, ordem); destroiLista(&L); L = L_aux; } else if (strcmp(comando, "imprime") == 0) { imprime(L); } scanf("%s", comando); } return 0; } //////////////////////////////////// /*************** BODIES *****************/ // (a) Insere um nó no início da Lista com um novo produto, que possui os valores passados por parâmetro. void insereNoInicio(Lista *L, int num_serie, double preco, char nome[64]) { // IMPLEMENTE ESTA FUNÇÃO No *p = criaNo(num_serie, preco, nome); //Cria um nó de um produto para inserir os dados p->prox = L->inicio; //Aponta a partir do início da lista encadeada L->inicio = p; //Coloca os dados do produto pro início L->tamanho++; //Aumenta o tamanho da lista para cada produto adicionado no encadeamento. } // (b) Remove o nó da lista cujo produto possua o número de série num_serie. // Assuma que o número de série é único na lista. // Se a lista estiver vazia ou não existir nenhum produto com o número de série, nada acontece. void removeProduto(Lista *L, int num_serie) { // IMPLEMENTE ESTA FUNÇÃO //caso a lista esteja vazia if (listaEstaVazia(L)) { return; } //variável que indica se o número de serie foi encontrado ou não // 0 para não // 1 para sim int encontrou = 0; //verifica se o número encontrado está no início if(L->inicio->prod->num_serie == num_serie) { L->inicio = L->inicio->prox; encontrou = 1; L->tamanho--; } //verifica se o número encontrado está em qualquer posição else { No *no = L->inicio; No *anterior = NULL; //percorre todo o nó da lista para encontrar o valor inserido while(no != NULL && encontrou == 0) { if(no->prod->num_serie == num_serie) { anterior->prox = no->prox; encontrou == 1; L->tamanho--; } anterior = no; no = no->prox; } } } // (c) Remove a primeira metade da Lista. Caso a lista possua um número ímpar de elementos, // considere que a primeira metade possui mais elementos // (Ex: se a lista possuir 5 elementos, a primeira metade possui os 3 primeiros elementos). // Se a lista tiver vazia, nada acontece. void removePrimeiraMetade(Lista *L) { // IMPLEMENTE ESTA FUNÇÃO //Estou pensando no código } // (d) Retorna a Lista invertida. Se a lista está vazia, retorne uma lista vazia. Lista *inverter(const Lista *L) { // IMPLEMENTE ESTA FUNÇÃO Lista *Outra; if ( L == NULL ) return -1; if ( Outra == NULL ) return -1; if (!listaEstaVazia(L)) { No *p = L->inicio; No *ant = NULL; while (p != NULL) { insereNoInicio(Outra, p->prod->num_serie, p->prod->preco, p->prod->nome); ant->prox = p->prox; p->prox = p; } } } // (e) Retorna a lista ordenada pelo número de série de seus produtos, de acordo com uma ordem passada pelo programa: // ordem=0 significa ordem crescente; // ordem=1 significa ordem decrescente. Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO //Estou pensando em como fazer if (ordem == 0){ if (listaEstaVazia(L)){ return; } else { } } else { if (listaEstaVazia(L)){ return; } else { } } } /************ FUNÇÕES JÁ IMPLEMENTADAS *************/ Produto *criaProduto(int num_serie, double preco, char nome[64]) { Produto *prod = (Produto *)calloc(1, sizeof(Produto)); prod->num_serie = num_serie; prod->preco = preco; strcpy(prod->nome, nome); return prod; } void destroiProduto(Produto **prod_ref) { Produto *prod = *prod_ref; if (prod != NULL) { free(prod); *prod_ref = NULL; } } No *criaNo(int num_serie, double preco, char nome[64]) { No *no = (No*) calloc(1, sizeof(No)); no->prod = criaProduto(num_serie, preco, nome); no->prox = NULL; return no; } Lista *criaLista() { return ((Lista*) calloc(1, sizeof(Lista))); } void destroiLista(Lista **L) { Lista *L_aux = *L; // remove todos os nós da lista No *p = L_aux->inicio; while (p != NULL) { No *no = p; p = p->prox; destroiProduto(&no->prod); free(no); } free(L_aux); *L = NULL; } int listaEstaVazia(const Lista *L) { return (L->inicio == NULL); } void imprime(const Lista *L) { printf("Tamanho da lista: %d\n", L->tamanho); printf("L -> "); if (!listaEstaVazia(L)) { No *p = L->inicio; while (p != NULL) { printf("(%d, %.2lf, %s) -> ", p->prod->num_serie, p->prod->preco, p->prod->nome); p = p->prox; } } printf("NULL\n\n"); }

Então, o código deu erro. Não saiu a lista invertida.

Eu ainda não entendi direito... Eu acho que assim daria um erro ao compilar. Na verdade, acho que tenho uma pequena ideia. Mas não sei se para você estaria certo: Criar um nó do qual aponta para o fim da lista. Eu iria criar um nó que aponta para o fim da lista? Basicamente assim? int faz_aquilo(const Lista *L, const Lista* Outra ) { if ( L == NULL ) return -1; if ( Outra == NULL ) return -1; if (!listaEstaVazia(L)) { No *p = L->fim; No *ant = NULL; while (p != NULL) { insereNoInicio(Outra, p->prod->num_serie, p->prod->preco, p->prod->nome); ant->prox = p->prox; } } }

@arfneto Ok. Vou postar o código. OBS: Tem algumas linhas do código que não posso alterá-las. /*************************** * LAB 04 - 02/12/2020 * SEU NOME - SEU PRONTUÁRIO ***************************/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> // struct que define um produto typedef struct _produto { int num_serie; // numero de série do produto char nome[64]; double preco; } Produto; // struct que define um nó curcular duplamente encadeado typedef struct _no { Produto *prod; struct _no *prox; } No; // struct que define uma Lista Ligada Simples typedef struct _lista { No *inicio; No *fim; int tamanho; // numero de nós da lista } Lista; /*********** HEADERS ***********/ Produto *criaProduto(int num_serie, double preco, char nome[64]); void destroiProduto(Produto **prod_ref); No *criaNo(int num_serie, double preco, char nome[64]); Lista *criaLista(); void destroiLista(Lista **L_ref); int listaEstaVazia(const Lista *L); void imprime(const Lista *L); void imprime_ultimo(const Lista *L); // A SEREM IMPLEMENTADAS POR VOCÊ void insereNoInicio(Lista *L, int num_serie, double preco, char nome[64]); void removeProduto(Lista *L, int num_serie); void removePrimeiraMetade(Lista *L); Lista *inverter(const Lista *L); Lista *ordenar(const Lista *L, int ordem); /*******************************/ int main() { Lista *L = criaLista(); char comando[64]; int ordem; int num_serie; char nome[64]; double preco; scanf("%s", comando); while (strcmp(comando, "para") != 0) { if (strcmp(comando, "insere_inicio") == 0) { scanf("%d", &num_serie); scanf("%lf", &preco); scanf(" %[^\t\n]s", nome); insereNoInicio(L, num_serie, preco, nome); } else if (strcmp(comando, "remove_produto") == 0) { scanf("%d", &num_serie); removeProduto(L, num_serie); } else if (strcmp(comando, "remove_primeira_metade") == 0) { removePrimeiraMetade(L); } else if (strcmp(comando, "inverte") == 0) { Lista *L_aux = inverter(L); destroiLista(&L); L = L_aux; } else if (strcmp(comando, "ordena") == 0) { scanf("%d", &ordem); Lista *L_aux = ordenar(L, ordem); destroiLista(&L); L = L_aux; } else if (strcmp(comando, "imprime") == 0) { imprime(L); } scanf("%s", comando); } return 0; } //////////////////////////////////// /*************** BODIES *****************/ // (a) Insere um nó no início da Lista com um novo produto, que possui os valores passados por parâmetro. void insereNoInicio(Lista *L, int num_serie, double preco, char nome[64]) { // IMPLEMENTE ESTA FUNÇÃO No *p = criaNo(num_serie, preco, nome); //Cria um nó de um produto para inserir os dados p->prox = L->inicio; //Aponta a partir do início da lista encadeada L->inicio = p; //Coloca os dados do produto pro início L->tamanho++; //Aumenta o tamanho da lista para cada produto adicionado no encadeamento. } // (b) Remove o nó da lista cujo produto possua o número de série num_serie. // Assuma que o número de série é único na lista. // Se a lista estiver vazia ou não existir nenhum produto com o número de série, nada acontece. void removeProduto(Lista *L, int num_serie) { // IMPLEMENTE ESTA FUNÇÃO //caso a lista esteja vazia if (listaEstaVazia(L)) { return; } //variável que indica se o número de serie foi encontrado ou não // 0 para não // 1 para sim int encontrou = 0; //verifica se o número encontrado está no início if(L->inicio->prod->num_serie == num_serie) { L->inicio = L->inicio->prox; encontrou = 1; L->tamanho--; } //verifica se o número encontrado está em qualquer posição else { No *no = L->inicio; No *anterior = NULL; //percorre todo o nó da lista para encontrar o valor inserido while(no != NULL && encontrou == 0) { if(no->prod->num_serie == num_serie) { anterior->prox = no->prox; encontrou == 1; L->tamanho--; } anterior = no; no = no->prox; } } } // (c) Remove a primeira metade da Lista. Caso a lista possua um número ímpar de elementos, // considere que a primeira metade possui mais elementos // (Ex: se a lista possuir 5 elementos, a primeira metade possui os 3 primeiros elementos). // Se a lista tiver vazia, nada acontece. void removePrimeiraMetade(Lista *L) { // IMPLEMENTE ESTA FUNÇÃO //verifica se a lista está vazia } // (d) Retorna a Lista invertida. Se a lista está vazia, retorne uma lista vazia. Lista *inverter(const Lista *L) { // IMPLEMENTE ESTA FUNÇÃO printf("Tamanho da lista: %d\n", L->tamanho); printf("L -> "); if (!listaEstaVazia(L)) { No *p = L->fim; No *ant = NULL; while (p != NULL) { printf("(%d, %.2lf, %s) -> ", p->prod->num_serie, p->prod->preco, p->prod->nome); ant->prox = p->prox; } } printf("NULL\n\n"); } // (e) Retorna a lista ordenada pelo número de série de seus produtos, de acordo com uma ordem passada pelo programa: // ordem=0 significa ordem crescente; // ordem=1 significa ordem decrescente. Lista *ordenar(const Lista *L, int ordem) { // IMPLEMENTE ESTA FUNÇÃO if (ordem == 0){ if (listaEstaVazia(L)){ return; } else { } } else { if (listaEstaVazia(L)){ return; } else { } } } /************ FUNÇÕES JÁ IMPLEMENTADAS *************/ Produto *criaProduto(int num_serie, double preco, char nome[64]) { Produto *prod = (Produto *)calloc(1, sizeof(Produto)); prod->num_serie = num_serie; prod->preco = preco; strcpy(prod->nome, nome); return prod; } void destroiProduto(Produto **prod_ref) { Produto *prod = *prod_ref; if (prod != NULL) { free(prod); *prod_ref = NULL; } } No *criaNo(int num_serie, double preco, char nome[64]) { No *no = (No*) calloc(1, sizeof(No)); no->prod = criaProduto(num_serie, preco, nome); no->prox = NULL; return no; } Lista *criaLista() { return ((Lista*) calloc(1, sizeof(Lista))); } void destroiLista(Lista **L) { Lista *L_aux = *L; // remove todos os nós da lista No *p = L_aux->inicio; while (p != NULL) { No *no = p; p = p->prox; destroiProduto(&no->prod); free(no); } free(L_aux); *L = NULL; } int listaEstaVazia(const Lista *L) { return (L->inicio == NULL); } void imprime(const Lista *L) { printf("Tamanho da lista: %d\n", L->tamanho); printf("L -> "); if (!listaEstaVazia(L)) { No *p = L->inicio; while (p != NULL) { printf("(%d, %.2lf, %s) -> ", p->prod->num_serie, p->prod->preco, p->prod->nome); p = p->prox; } } printf("NULL\n\n"); }

@arfneto Entendi mais ou menos o que você disse. Vou traduzir do português para C se entendi. 1) Caso a lista não esteja vazia: if (!listaEstaVazia(L)){ //comando da função } 2) Crio um ponteiro de uma lista chamado "aux": Lista *aux; 3) Crio um ponteiro de "No" chamado "p" que é equivalente ao nó do fim da lista: No *p = L->fim 4) Crio um ponteiro de "No" chamado "ant", ou seja, quero que percorra para o anterior de "p": No *ant = NULL 5) Enquanto o ponteiro "p" não for nulo, imprime a lista invertida: while (p != NULL) { printf("(%d, %.2lf, %s) -> ", p->prod->num_serie, p->prod->preco, p->prod->nome); ant->prox = p->prox; } É mais ou menos desta maneira?

@arfneto Então, tenho o programa inteiro para algum de vocês compilar. Se não se importar, posso publicar neste comentário. E sobre as frases em negrito, eu queria inverter a lista pelo nó. Por exemplo, se eu haver uma lista simples com 5 elementos, preciso fazer com que inverta os nós da lista começando pelo último elemento. Certo? L -> (800, 99.99, Polystation 5) -> (785, 299.99, Mouse Gamer) -> (584, 899.99, Intel Core i9 8700U) -> (123, 34.99, Mousepad Razer) -> (981, 199.99, XCaixa Series Y) -> NULL L -> (981, 199.99, XCaixa Series Y) -> (123, 34.99, Mousepad Razer) -> (584, 899.99, Intel Core i9 8700U)-> (785, 299.99, Mouse Gamer) -> (800, 99.99, Polystation 5) -> NULL @arfneto mas fica basicamente assim? Lista *inverter(const Lista *L) { // IMPLEMENTE ESTA FUNÇÃO Lista *aux = L; No *p; No *ant = NULL; if (listaEstaVazia(L)){ return; } else { aux = L->fim; while(aux != NULL){ aux = L->fim; p = p->ant; L->fim = aux; } } return aux; }

Boa tarde pessoal Estou com uma dúvida em um exercício de lista encadeada simples. Queria inserir o nó do início como fim, e o nó do fim como o início. É basicamente nessa maneira: **ANTES** L -> (800, 99.99, Polystation 5) -> (981, 199.99, XCaixa Series Y) -> NULL **DEPOIS** L -> (981, 199.99, XCaixa Series Y) -> (800, 99.99, Polystation 5) -> NULL Mas estou com um certo problema com o código, que quando executo o comando, ele não inverte. A) Função que inverte o nó da lista // (d) Retorna a Lista invertida. Se a lista está vazia, retorne uma lista vazia. Lista *inverter(const Lista *L) { // IMPLEMENTE ESTA FUNÇÃO Lista* q; /* variável auxiliar para nova lista */ No *p; int aux; for (p = L; p != NULL; p = p->prox) if (p-> == NULL) { aux = p->prox; p->prox = NULL; return p; } } B) Structs de `_produto`, `_no` e `_lista` // struct que define um produto typedef struct _produto { int num_serie; // numero de série do produto char nome[64]; double preco; } Produto; // struct que define um nó curcular duplamente encadeado typedef struct _no { Produto *prod; struct _no *prox; } No; // struct que define uma Lista Ligada Simples typedef struct _lista { No *inicio; No *fim; int tamanho; // numero de nós da lista } Lista; C) Código acionado na `main()`: else if (strcmp(comando, "inverte") == 0) { Lista *L_aux = inverter(L); destroiLista(&L); L = L_aux; }

Boas, pessoal! Estou com dúvida de como remover um produto em uma lista encadeada simples. Só que eu não consegui remover um produto na lista. Algúem pode me ajudar? Função que remove o produto em qualquer nó. // (b) Remove o nó da lista cujo produto possua o número de série num_serie. // Assuma que o número de série é único na lista. // Se a lista estiver vazia ou não existir nenhum produto com o número de série, nada acontece. void removeProduto(Lista *L, int num_serie) { // IMPLEMENTE ESTA FUNÇÃO if(!listaEstaVazia(L)){ No *no_produto = L->inicio; L->inicio = L->inicio->prox; destroiProduto(num_serie); L->tamanho--; if (L->tamanho == 0){ L->fim = NULL; } } } Função que destroi o produto void destroiProduto(Produto **prod_ref) { Produto *prod = *prod_ref; if (prod != NULL) { free(prod); *prod_ref = NULL; } } Processo que irá ser executado na main() else if (strcmp(comando, "remove_produto") == 0) { scanf("%d", &num_serie); removeProduto(L, num_serie); }

Ok Sim. Talvez esteja superestimando ele. Mas estou começando a entender aos poucos. Achei este exercício da faculdade bastante difícil. Por isso, queria uma ajuda com este exercício. Muito obrigado pela ajuda!!

Acho que agora, estou entendendo. Agora pra fazer a somatória, encontrar o menor valor e o maior valor da sub-matriz, é só também procurar nos índices da submatriz e declará-los como "maior" e "menor"? tipo assim:

Isso!! "Pegar" era exatamente o que você havia dito. Agora, então, pra substituir, devo colocar o valor, e substituir em um intervalo (x,y) da matriz "teste" pelo número que eu quero? Por exemplo, neste código aqui: scanf("%d %d %d %d $d", x1, y1, x2, y2, valor); for (int i=x1; i<x2; i++){ for (int j=y1; j<y2; j++){ teste[i][j] = valor; printf("%d", teste[i][j]); } printf("\n"); }

beleza. E se eu quiser pegar os elementos em um intervalo (x,y), devo criar uma matriz (ex: int teste2[lin][col])?