struct Nodo { int struct Nodo struct Nodo typedef struct Nodo *PNodo; int ConstruirLista (PNodo *H, PNodo *T) { int Criar

Transcrição

1 struct Nodo { int Elemento; struct Nodo *Prox; struct Nodo *Ant; ; typedef struct Nodo *PNodo; Copiar para o ficheiro ListasLigadasDuplas.h e adaptar as funções associadas às seguintes operações: Criar; CriarNodo; LibertarNodo; Vazia; Listar, ListarContrario; InserirPrimeiroElemento, InserirCabeca. 1) Implementar uma função para preencher uma lista ligada com valores inteiros positivos, inseridos a partir do teclado. int ConstruirLista (PNodo *H, PNodo *T) { int X; Criar(H, T); printf( Inserir um inteiro positivo (negativo para terminar): \n ); scanf( %d, &X); if (X >= 0) InserirPrimeiroElemento(H, T, X); return 0; printf( Inserir um inteiro positivo (negativo para terminar): \n ); scanf( %d, &X); while (X >= 0) { *H = InserirCabeca(*H, X); printf( Inserir um inteiro positivo (negativo para terminar): \n ); scanf( %d, &X); #include <stdio.h> #include <stdlib.h> #include ListasLigadasDuplas.h // deve estar na diretoria/pasta do main PNodo Head, Tail; ConstruirLista(&Head, &Tail); printf( Listar do início para o fim:\n ); Listar(Head);

2 printf( \nlistar do fim para o início:\n ); ListarContrario(Tail); printf( \n ); 2) Implementar uma função para determinar a soma dos elementos duma lista ligada com valores inteiros positivos. int SomaLista (PNodo H/T) { int soma = 0; PNodo P = H/T; while (P!= NULL) { soma = soma + P->Elemento; P = P->Prox/Ant; return soma; // acrescentar ao main anterior int S; S = SomaLista(Head/Tail); printf( Soma = %d\n, S); 3) Implementar uma função para determinar a quantidade de elementos duma lista ligada com valores inteiros positivos maiores ou iguais a um valor K. int NumeroMaioresIguaisK (PNodo H/T, int K) { int num = 0; PNodo P = H/T; while (P!= NULL) { if (P->Elemento >= K) num++; P = P->Prox/Ant; return num;

3 // acrescentar ao main anterior int S, N, K; printf( Insira um valor inteiro positivo:\n ); scanf( %d, &K); N = NumeroMaioresIguaisK(Head/Tail, K); printf( Numero de elementos maiores ou iguais a %d = %d\n, K, S); Acrescentar ao ficheiro ListasLigadasDuplas.h e adaptar as funções associadas às seguintes operações: Consultar, ConsultarRec; ProcurarAnterior, ProcurarAnteriorRec; Remove, RemoverRec. 4) Implementar uma função que, dados uma lista ligada com valores interios positivos e um inteiro X, remova um elemento da lista com valor igual a X, caso exista. int RemoverIgual (PNodo *H, PNodo *T, int X) { if (ConsultarCabeca(*H, X) == 0) // X não está na lista return 0; if (*H == *T) // se só existe 1 elemento RemoverUnicoElemento(H, T); if (*H->Elemento == X) // está na cabeça if (*T->Elemento == X) // está na cauda *T = RemoverCauda(*T); RemoverEntreDoisElementos(*H, X); // está no meio return 1;

4 // Acrescentar ao main. int K; printf( Insira um valor inteiro positivo:\n ); scanf( %d, &K); if (RemoverIgual(&Head, &Tail, K)) printf( Elemento %d removido.\n, K); 5) Implementar uma função que, dados uma lista ligada com valores interios positivos e um inteiro X, remova todos os elementos da lista com valores iguais a X, caso existam. // Versão 1: usar as funções já existentes void RemoverIguais (PNodo *H, PNodo *T, int X) { while (ConsultarCabeca(*H, X) == 1) // X está na lista if (*H == *T) // se só existe 1 elemento RemoverUnicoElemento(H, T); if (*H->Elemento == X) // está na cabeça if (*T->Elemento == X) // está na cauda *T = RemoverCauda(*T); RemoverEntreDoisElementos(*H, X); // meio Acrescentar ao main.

5 // Versão 2: sem usar as funções existentes void RemoverIguais (PNodo *H, PNodo *T, int X) { PNodo P, PAnt; while (*H!= NULL && *H->Elemento == X) { // remover todos os nodos P = *H; // com X do início da lista *H = *H->Prox; LibertarNodo(P); if (*H == NULL) // a lista ficou vazia com a retirada dos nodos *T = NULL; // atualizar cauda com NULL também // Lista não está vazia e o seu 1º elemento é diferente de X PAnt = *H; // PAnt aponta sempre para um nodo sem X P = *H->Prox; while (P!= *T) { percorrer todos menos o da cauda (remoção diferente) if (P->Elemento == X) { // remover este nodo PAnt->Prox = P->Prox; // ligar o anterior de P ao seguinte P->Prox->Ant = Pant; // ligar o seguinte de P ao anterior LibertarNodo(P); P = PAnt->Prox; // P aponta para o próximo de PAnt { PAnt = P; P = P->Prox; if (*T->Elemento == X) { P = *T; // para libertar o nodo na cauda if (*H == *T) { // lista só com 1 elemento *H = NULL; // fica vazia *T = NULL; { // lista com vários elementos *T->Ant->Prox = NULL; // atualizar o nodo da cauda *T = *T->Ant; // atualizar o ponteiro para a cauda LibertarNodo(P); Acrescentar ao main.

6 6) Implementar uma função que, dados uma lista ligada L com valores inteiros positivos e um número inteiro positivo N, remova da lista L os seus N primeiros elementos e retorne a lista resultante. Caso N seja maior do que o comprimento da lista, todos os seus elementos devem ser removidos e o resultado deve ser uma lista vazia. void RemoverNPrimeiros (PNodo *H, PNodo *T, int N) { int i, k = Tamanho(*H); if (k > N) // remover os k primeiros elementos na cabeça for (i = 1; i <= k; i++) { for (i = 1; i < k; i++) // remover os k-1 elementos à cabeça RemoverUnicoElemento(H, T); // remover o único que ficou Acrescentar ao main.