Programando: Estruturas de dados - Resolução da lista 7 (Listas Encadeadas)

Olá pessoal esse post tem a resolução dos exercícios do 1 - 10. O exercício 11 postarei mais tarde. Qualquer duvida comentem, ok? A outra coisa se faz necessário usar o arquivo cabeçalho que eu criei (utils.h). Eu postei ele aqui no blog http://programando-ads.blogspot.com.br/2013/01/lista-de-exercicios-eda-listas.html.

Exercicio 1.


#include 
#include 
#include "utils.h"

int lst_comp (Lista *l) {
 int i = 0;
 
 while (l != NULL) {
  i++;
  l = l->prox;
 }
 
 return i;
}

int main(void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 20);
 l = lst_insere (l, 20);
 l = lst_insere (l, 20);
 l = lst_insere (l, 20);
 l = lst_insere (l, 20);
 
 printf ("\ncomprimento da lista: %d \n", lst_comp (l));
 
 return 0;
}

Exercício 2.


#include 
#include 
#include "utils.h"

int lst_maiores (Lista *l, int n) {
 Lista *p = l;
 int x = 0;
 
 for (p = l; p != NULL; p = p->prox) {
  if (p->value > n)
   x++;
 }
 
 return x;
}

int main(void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 20);
 l = lst_insere (l, 120);
 l = lst_insere (l, 40);
 l = lst_insere (l, -100);
 l = lst_insere (l, 13);
 
 system ("clear");
 printf ("\n Numero de elementos maiores que %d = %d\n", 20, lst_maiores (l, 20));
 printf ("\n Numero de elementos maiores que %d = %d\n", 10, lst_maiores (l, 10));
 printf ("\n Numero de elementos maiores que %d = %d\n", 0, lst_maiores (l, 0));
 printf ("\n Numero de elementos maiores que %d = %d\n", 240, lst_maiores (l, 240));
 printf ("\n Numero de elementos maiores que %d = %d\n", 2, lst_maiores (l, 2));
 
 return 0;
}

Exercício 3.


#include 
#include 
#include "utils.h"

int main(void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 20);
 l = lst_insere (l, 120);
 l = lst_insere (l, 40);
 lst_imprime (l);
 Lista *y = lst_ultimo (l);
 printf ("\nUltimo elemento da lista %d\n",  y->value);
 
 return 0;
}

Exercício 4.


#include 
#include 
#include "utils.h"

Lista *lst_concatena (Lista *l1, Lista *l2) {
 Lista  *p = NULL;
 
 p = lst_ultimo (l1);
 p->prox = l2;
}

int main (void) {
 Lista *l1;
 Lista *l2;
 l1 = lst_cria ();
 l1 = lst_insere (l1, 1);
 l1 = lst_insere (l1, 2);
 l1 = lst_insere (l1, 3);
 
 l2 = lst_cria ();
 l2 = lst_insere (l2, 4);
 l2 = lst_insere (l2, 5);
 l2 = lst_insere (l2, 6);
 
 Lista *p = lst_concatena (l1, l2);
 printf ("Valor: %d\n", p->prox->value);
 
 return 0;
}

Exercício 5.


#include 
#include 
#include "utils.h"

Lista *lst_retira_n (Lista *l, int n) {
 Lista *p =NULL;

 while (l != NULL) {
  if (l->value != n) 
   p = lst_insere (p, l->value);
  
  l = l->prox;
 }
 return p;
}

int main (void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 10);
 l = lst_insere (l, 50);
 l = lst_insere (l, 10);
 l = lst_insere (l, 50);
 l = lst_insere (l, 10);
 
 l = lst_retira_n (l, 50);
 lst_imprime (l);
 
 return 0;
}

Exercício 6.


#include 
#include 
#include "utils.h"

Lista *lst_separa (Lista *l, int n) {
 Lista *p = NULL;
 while (l != NULL && l->value != n) 
  l = l->prox;
  
 l = l->prox;
 
 while (l != NULL) {
  p = lst_insere (p, l->value);
  l = l->prox;
 }
 
 return p;
}

int main (void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 10);
 l = lst_insere (l, 50);
 l = lst_insere (l, 60);
 l = lst_insere (l, 70);
 l = lst_insere (l, 80);
 
 printf ("\nOcorrencia: 50\n");
 printf ("\nLista Original\n");
 lst_imprime (l);
 printf ("\n\nLista separada:");
 l = lst_separa (l, 50);
 lst_imprime (l);
 
 return 0;
}

Exercício 7.


#include 
#include 
#include "utils.h"

Lista *lst_merge (Lista *l1, Lista *l2) {
 Lista *p = NULL;
 Lista *p1 = NULL;
 Lista *p2 = NULL;
 
 for (p1=l1, p2=l2; p1 != NULL && p2 != NULL; p1=p1->prox, p2=p2->prox) {
  p = lst_insere (p, l2->value);
  l2 = l2->prox;
  
  p = lst_insere (p, l1->value);
  l1 = l1->prox;
 }

 return p;
}

int main (void) {
 Lista *l1;
 Lista *l2;
 l1 = lst_cria ();
 l1 = lst_insere (l1, 1);
 l1 = lst_insere (l1, 2);
 l1 = lst_insere (l1, 3);
 
 l2 = lst_cria ();
 l2 = lst_insere (l2, 4);
 l2 = lst_insere (l2, 5);
 l2 = lst_insere (l2, 6);
 
 Lista *p;
 p = lst_merge (l1, l2);
 lst_imprime (p);
 
 return 0;
}

Exercício 8.


#include 
#include 
#include "utils.h"

Lista *lst_inverte (Lista *l) {
 Lista *p;
 Lista *aux=NULL;

 p=l->prox;
 l->prox=NULL;

 while(p!=NULL)
 {
  aux=p->prox;
  p->prox=l;
  l=p;
  p=aux;
    }

 return l; 
}

int main (void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 10);
 l = lst_insere (l, 20);
 l = lst_insere (l, 30);
 
 puts ("Matriz Original");
 lst_imprime (l);
 
 puts ("\nMatriz Invertida");
 l = lst_inverte (l);
 lst_imprime (l);
 
 return 0;
}

Exercício 9.


#include 
#include 
#include "utils.h"

int lst_igual (Lista *l1, Lista *l2) {
 for (l1, l2; l1 != NULL && l2 != NULL; l1 = l1->prox, l2 = l2->prox) {
  if (l1->value != l2->value)
   return 0;
 }
 return 1;
}

int main (void) {
 Lista *l1, *l2;
 l1 = lst_cria ();
 l1 = lst_insere (l1, 10);
 l1 = lst_insere (l1, 20);
 
 l2 = lst_cria ();
 l2 = lst_insere (l2, 1);
 l2 = lst_insere (l2, 20);
 
 if (lst_igual(l1, l2)) 
  printf ("\nAs listas são iguais!\n");
 else
  printf ("\nAs listas são diferentes\n");

 return 0;
}

Exercício 10.


#include 
#include 
#include "utils.h"

Lista *lst_copia (Lista *l) {
 Lista *p = l;
 Lista *y = NULL;
 
 while (p != NULL) {
  y = lst_insere (y, p->value);
  p = p->prox;
 }

 return y;
}


int main (void) {
 Lista *l;
 l = lst_cria ();
 l = lst_insere (l, 20);
 l = lst_insere (l, 100);
 l = lst_insere (l, 30);
 l = lst_insere (l, 20);
 l = lst_insere (l, 20);
 
 Lista *y;
 y = lst_copia (l);
 
 system ("clear");
 lst_imprime (y);
 
 return 0;
}

Programando

quarta-feira, 9 de janeiro de 2013

Estruturas de dados - Resolução da lista 7 (Listas Encadeadas)

Nenhum comentário:

Postar um comentário

Novidade!!! Agora vamos ter canal no Youtube =D

Paginas

Redes Social