[C] Funzione che richiama funzione e liste

**{Bl4d3}** · 12-01-2006, 13:59

Ragazzi, allora, mi trovo di fronte ad un problema che proprio non riescono a risolvere, e non me lo spiego nemmeno.

Allora, ho queste due funzioni:

codice:

int cerca_occorrenza(Lista L, int occ, item_type_lista *el, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Head;
    int pos = 1;
    int occorrenza = 0;
    while (temp)
    {
      if ((*compare)(&temp->info, el) == 0)
	if (++occorrenza == occ)
	  return pos;
      pos++;
      temp = temp->next;
    }
  }
  return 0;
}

int modifica_occorrenza(Lista L, int occ, item_type_lista *vecchio, item_type_lista *nuovo, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    int pos = cerca_occorrenza(L, occ, vecchio, compare);
    printf("pos:\t%d\n", pos);
    if (pos)
      return assegna(L, pos, nuovo);
  }
  return 0;
}

allora, come potete vedere modifica_occorrenza richiama la funzione cerca_occorrenza. La funzione compare serve a fare il confronto tra due elementi della lista.
Se richiamo la funzione trova_occorrenza dal main funziona perfettamente, ma sulla stessa lista richiamo modifica_occorrenza e trova_occorrenza restituisce 0, come se non trovasse l'occorrenza.

La funzione modifica_occorrenza la richiamo così:

codice:

eliminato = elimina_occorrenza(L, inserito, &elemento_vecchio, &elemento, compara);

e compara è dichiarata:

codice:

int compara(item_type_lista *, item_type_lista *);

scusate... avevo dimenticato il linguaggio

**alka** · 12-01-2006, 14:08

Linguaggio? C++?

**unomichisiada** · 12-01-2006, 14:12

Se posti tutto il codice in modo che non mi debba scrivere la struttura per la lista ed inserirci i dati io per fare prove,cerco di autarti.Posta tutto il prog pronto all'esecuzione,main compresa

**{Bl4d3}** · 12-01-2006, 14:20

lo devo spezzare in due parti:

main:

codice:

#include <stdio.h>
#include <stdlib.h>

#define item_type_lista float

#include "../H/Liste/liste.h"

void stampa(item_type_lista *x)
{
  printf("%.2f\t", *x);
}

int compara(item_type_lista *uno, item_type_lista *due)
{
  return (int) (*uno - *due);
}

void ottieni_elemento(item_type_lista *ritorno)
{
  scanf("%f%*c",ritorno);
}

int main()
{
  
  Lista L = crea_lista();
  int scelta, posizione;
  int inserito, eliminato;
  item_type_lista elemento, elemento_vecchio;
  do {
    system("clear");
    if (!stampa_lista(L,stampa))
      printf("Lista vuota\n");
    printf("1) Inserisci elemento 2) Elimina elemento 3) Leggi elemento\n"
	   "4) Inserisci in testa 5) Inserisci in coda 6) Elimina in testa\n"
	   "7) Elimina in coda 8) Leggi in testa 9) Leggi in coda\n"
	   "10) Assegna 11) Modifica elemento 12) Modifica occorrenza\n"
	   "13) Modifica ultimo 14) Cerca 15) Cerca occorrenza\n"
	   "16) Cerca ultimo 17) Elimina elemento 18) Elimina occorrenza\n"
	   "19) Elimina ultimo 20) Elimina tutte le occorrenze di un elemento 21) Inserimento orinato\n"
	   "0) Fine\n\nScelta: ");
    scanf("%d%*c",&scelta);
    switch (scelta)
    {
      case 1:
	printf("Elemento da inserire: ");
	ottieni_elemento(&elemento);
	printf("Posizione: ");
	scanf("%d%*c",&posizione);
	inserito = inserisci(L,posizione,&elemento);
	if (inserito)
	  printf("Elemento inserito\n");
	scanf("%*c");
	break;
      case 2:
	printf("Posizione da eliminato: ");
	scanf("%d%*c",&posizione);
	eliminato = elimina(L, posizione, &elemento);
	if (eliminato)
	{
	  printf("L'elemento eliminato e': ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 3:
	printf("Posizione da esaminare: ");
	scanf("%d%*c",&posizione);
	eliminato = leggi(L,posizione,&elemento);
	if (eliminato)
	{
	  printf("L'elemento in posizione %d e': ", posizione);
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 4:
	printf("Elemento da inserire: ");
	ottieni_elemento(&elemento);
	inserito = inserisci_testa(L,&elemento);
	if (inserito)
	  printf("Elemento inserito\n");
	scanf("%*c");
	break;
      case 5:
	printf("Elemento da inserire: ");
	ottieni_elemento(&elemento);
	inserito = inserisci_coda(L,&elemento);
	if (inserito)
	  printf("Elemento inserito\n");
	scanf("%*c");
	break;
      case 6:
	eliminato = elimina_testa(L, &elemento);
	if (eliminato)
	{
	  printf("L'elemento eliminato e': ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 7:
	eliminato = elimina_coda(L, &elemento);
	if (eliminato)
	{
	  printf("L'elemento eliminato e': ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 8:
	eliminato = leggi_testa(L,&elemento);
	if (eliminato)
	{
	  printf("L'elemento in testa e': ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 9:
	eliminato = leggi_coda(L,&elemento);
	if (eliminato)
	{
	  printf("L'elemento in coda e': ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 10:
	printf("Nuovo elemento: ");
	ottieni_elemento(&elemento);
	printf("Posizione: ");
	scanf("%d%*c",&posizione);
	if ((eliminato = assegna(L, posizione, &elemento)))
	  printf("Elemento modificato\n");
	scanf("%*c");
	break;
      case 11:
	printf("Vecchio elemento: ");
	ottieni_elemento(&elemento);
	printf("Nuovo elemento: ");
	ottieni_elemento(&elemento);
	eliminato = modifica_elemento(L, &elemento_vecchio, &elemento, compara);
	if (eliminato)
	  printf("Elemento modificato\n");
	scanf("%*c");
	break;
      case 12:
	printf("Vecchio elemento: ");
	ottieni_elemento(&elemento);
	printf("Occorrenza: ");
	scanf("%d%*c", &inserito);
	printf("Nuovo elemento: ");
	ottieni_elemento(&elemento);
	eliminato = modifica_occorrenza(L, inserito, &elemento_vecchio, &elemento, compara);
	if (eliminato)
	  printf("Elemento modificato\n");
	scanf("%*c");
	break;
      case 13:
	printf("Vecchio elemento: ");
	ottieni_elemento(&elemento);
	printf("Nuovo elemento: ");
	ottieni_elemento(&elemento);
	eliminato = modifica_ultimo(L, &elemento_vecchio, &elemento, compara);
	if (eliminato)
	  printf("Elemento modificato\n");
	scanf("%*c");
	break;
      case 14:
	printf("Elemento da cercare: ");
	ottieni_elemento(&elemento);
	eliminato = cerca(L, &elemento, compara);
	if (eliminato)
	  printf("Elemento presente alla posizione %d\n",eliminato);
	else
	  printf("Elemento non presente nella lista\n");
	scanf("%*c");
	break;
      case 15:
	printf("Elemento da cercare: ");
	ottieni_elemento(&elemento);
	printf("Occorrenza: ");
	scanf("%d%*c", &inserito);
	eliminato = cerca_occorrenza(L, inserito, &elemento, compara);
	if (eliminato)
	  printf("Elemento trovato in posizione %d\n", eliminato);
	scanf("%*c");
	break;
      case 16:
	printf("Elemento da cercare: ");
	ottieni_elemento(&elemento);
	eliminato = cerca_ultimo(L, &elemento, compara);
	if (eliminato)
	  printf("Elemento trovato in posizione %d\n", eliminato);
	scanf("%*c");
	break;
      case 17:
	printf("Elemento da eliminare: ");
	ottieni_elemento(&elemento_vecchio);
	eliminato = elimina_elemento(L, &elemento_vecchio, &elemento, compara);
	if (eliminato)
	{
	  printf("Elemento eliminato: ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 18:
	printf("Elemento da eliminare: ");
	ottieni_elemento(&elemento_vecchio);
	printf("Occorrenza: ");
	scanf("%d%*c",&inserito);
	eliminato = elimina_occorrenza(L, inserito, &elemento_vecchio, &elemento, compara);
	if (eliminato)
	{
	  printf("Elemento eliminato: ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 19:
	printf("Elemento da eliminare: ");
	ottieni_elemento(&elemento_vecchio);
	eliminato = elimina_ultimo(L, &elemento_vecchio, &elemento, compara);
	if (eliminato)
	{
	  printf("Elemento eliminato: ");
	  stampa(&elemento);
	}
	scanf("%*c");
	break;
      case 20:
	printf("Elemento da eliminare: ");
	ottieni_elemento(&elemento_vecchio);
	while (elimina_elemento(L, &elemento_vecchio, &elemento, compara))
	  ;
	printf("Eliminate tutte le occorrenze dell'elemeneto\n");
	scanf("%*c");
	break;
      case 21:
	printf("Elemento da inserire: ");
	ottieni_elemento(&elemento);
	if (inserimento_ordinato(L, &elemento, compara))
	  printf("Elemento inserito\n");
	scanf("%*c");
	break;
   default:
	break;
    }
  } while (scelta != 0);
  return 0;
}

**{Bl4d3}** · 12-01-2006, 14:20

codice per liste:

codice:

#include <stdio.h>
#include <stdlib.h>
#include "liste.h"

struct campo_lista {
  item_type_lista info;
  struct campo_lista *next, *prev;
};

typedef struct LISTA {
  struct campo_lista *Head, *Tail;
  unsigned lunghezza;
} *Lista_ls;

Lista crea_lista(void)
{
  Lista_ls l = (Lista_ls)malloc(sizeof(struct LISTA));
  l->lunghezza = 0;
  l->Head = l->Tail = NULL;
  return (Lista) l;
}
  
int inserisci(Lista L, int pos, item_type_lista *elemento)
{
  if (!lista_piena(L))
  {
    Lista_ls l = (Lista_ls) L;
    if (pos > 0 && pos <= l->lunghezza + 1)
    {
      struct campo_lista *nuovo = (struct campo_lista *)malloc(sizeof(struct campo_lista));
      if (nuovo != NULL)
      {
        nuovo->info = *elemento;
        if (pos == 1)
        {
          nuovo->prev = NULL;
	  nuovo->next = l->Head;
	  if (l->Head)
	    l->Head->prev = nuovo;
	  if (l->Tail == NULL)
	    l->Tail = nuovo;
	  l->Head = nuovo;
        }
        else if (pos == l->lunghezza + 1)
        {
	  nuovo->next = NULL;
	  nuovo->prev = l->Tail;
	  l->Tail->next = nuovo;
	  l->Tail = nuovo;
        }
        else if (pos == l->lunghezza)
        {
	  nuovo->next = l->Tail;
	  nuovo->prev = l->Tail->prev;
	  l->Tail->prev->next = nuovo;
	  l->Tail->prev = nuovo;
        }
        else
        {
	  struct campo_lista *temp = l->Head->next;
	  int i = 2;
	  while (i != pos)
	  {
	    temp = temp->next;
	    i++;
	  }
	  nuovo->next = temp;
	  nuovo->prev = temp->prev;
	  temp->prev->next = nuovo;
	  temp->prev = nuovo;
        }
        l->lunghezza++;
        return 1;
      }
    }
  }
  return 0;
}

int elimina(Lista L, int pos, item_type_lista *ritorno)
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    if (pos > 0 && pos <= l->lunghezza)
    {
      struct campo_lista *temp = NULL;
      if (pos == 1)
      {
        *ritorno = l->Head->info;
        temp = l->Head;
        l->Head = l->Head->next;
        if (l->Head)
	  l->Head->prev = NULL;
        else
	  l->Tail = NULL;
        free(temp);
      }
      else if (pos == l->lunghezza)
      {
        *ritorno = l->Tail->info;
        temp = l->Tail;
        l->Tail = l->Tail->prev;
        l->Tail->next = NULL;
      }
      else
      {
        int i = 2;
        temp = l->Head->next;
        while (i++ != pos)
	  temp = temp->next;
        *ritorno = temp->info;
        temp->next->prev = temp->prev;
        temp->prev->next = temp->next;
        free(temp);
      }
      l->lunghezza--;
      return 1;
    }
  }
  return 0;
}

int leggi(Lista L, int pos, item_type_lista *ritorno)
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    if (pos > 0 && pos <= l->lunghezza)
    {
      if (pos == 1)
        *ritorno = l->Head->info;
      else if (pos == l->lunghezza)
        *ritorno = l->Tail->info;
      else
      {
        int i = 2;
        struct campo_lista *temp = l->Head->next;
        while (i++ != pos)
	  temp = temp->next;
        *ritorno = temp->info;
      }
      return 1;
    }
  }
  return 0;
}

int lunghezza(Lista L)
{
  Lista_ls l = (Lista_ls) L;
  return l->lunghezza;
}

int lista_vuota(Lista L)
{
  Lista_ls l = (Lista_ls) L;
  return l->lunghezza == 0;
}

int lista_piena(Lista L)
{
  return 0;
}

int stampa_lista(Lista L, void (*stampa)(item_type_lista *))
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Head;
    while (temp)
    {
      (*stampa)(&(temp->info));
      temp = temp->next;
    }
    printf("\n");
    return 1;
  }
  return 0;
}

int inserisci_testa(Lista L, item_type_lista *el)
{
  return inserisci(L, 1, el);
}

int inserisci_coda(Lista L, item_type_lista *el)
{
  return inserisci(L, lunghezza(L)+1, el);
}

int elimina_testa(Lista L, item_type_lista *el)
{
  return elimina(L, 1, el);
}

int elimina_coda(Lista L, item_type_lista *el)
{
  return elimina(L, lunghezza(L), el);
}

int leggi_testa(Lista L, item_type_lista *el)
{
  return leggi(L, 1, el);
}

int leggi_coda(Lista L, item_type_lista *el)
{
  return leggi(L, lunghezza(L), el);
}

int assegna(Lista L, int pos, item_type_lista *el)
{
  item_type_lista temp;
  int eliminato = elimina(L, pos, &temp);
  if (eliminato)
    return inserisci(L, pos, el);
  return 0;
}

int cerca(Lista L, item_type_lista *el, int (*compare)(item_type_lista *, item_type_lista *))
{
  return cerca_occorrenza(L, 1, el, compare);
}

int cerca_occorrenza(Lista L, int occ, item_type_lista *el, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Head;
    int pos = 1;
    int occorrenza = 0;
    while (temp)
    {
      if ((*compare)(&temp->info, el) == 0)
	if (++occorrenza == occ)
	  return pos;
      pos++;
      temp = temp->next;
    }
  }
  return 0;
}

int modifica_occorrenza(Lista L, int occ, item_type_lista *vecchio, item_type_lista *nuovo, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    int pos = cerca_occorrenza(L, occ, vecchio, compare);
    printf("pos:\t%d\n", pos);
    if (pos)
      return assegna(L, pos, nuovo);
  }
  return 0;
}

int modifica_elemento(Lista L, item_type_lista *vecchio, item_type_lista *nuovo, int (*compare)(item_type_lista *, item_type_lista *))
{
  return modifica_occorrenza(L, 1, vecchio, nuovo, compare);
}

int modifica_ultimo(Lista L, item_type_lista *vecchio, item_type_lista *nuovo, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    int pos = cerca_ultimo(L, vecchio, compare);
    if (pos)
      return assegna(L, pos, nuovo);
  }
  return 0;
}

int cerca_ultimo(Lista L, item_type_lista *elemento, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Tail;
    int pos = l->lunghezza;
    while (temp)
    {
      if ((*compare)(elemento, &temp->info) == 0)
	return pos;
      pos--;
      temp = temp->prev;
    }
  }
  return 0;
}

int elimina_elemento(Lista L, item_type_lista *elemento, item_type_lista *ritorno, int (*compare)(item_type_lista *, item_type_lista *))
{
  return elimina_occorrenza(L, 1, elemento, ritorno, compare);
}

int elimina_occorrenza(Lista L, int occ, item_type_lista *elemento, item_type_lista *ritorno, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    int pos = cerca_occorrenza(L, occ, elemento, compare);
    if (pos)
      return elimina(L, pos, ritorno);
  }
  return 0;
}

int elimina_ultimo(Lista L, item_type_lista *elemento, item_type_lista *ritorno, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    int pos = cerca_ultimo(L, elemento, compare);
    if (pos)
      return elimina(L, pos, ritorno);
  }
  return 0;
}

int inserimento_ordinato(Lista L, item_type_lista *elemento, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_piena(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Head;
    int pos = 1;
    while (temp != NULL)
    {
      if ((*compare)(elemento, &(temp->info)) > 0)
      {
	temp = temp->next;
	pos++;
      }
      else
	return inserisci(L, pos, elemento);
    }
    return inserisci(L, pos, elemento);
  }
  return 0;
}

**unomichisiada** · 12-01-2006, 14:25

Scusa se insisto ma mancano gli headers con i prototipi e ovviamente mi da errore

**{Bl4d3}** · 12-01-2006, 14:25

la cosa strana è che cerca_occorrenza funziona perfettamente quanda richiamata dal main... ma quando la richiamo da modifica_occorrenza non va...

hai ragione, scusa:

codice:

#ifndef _LISTA_
#define _LISTA_

#ifndef item_type_lista
#define item_type_lista int
#endif

typedef void * Lista;

Lista crea_lista(void);
int inserisci(Lista, int, item_type_lista *);
int inserisci_testa(Lista, item_type_lista *);
int inserisci_coda(Lista, item_type_lista *);
int inserimento_ordinato(Lista, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina(Lista, int, item_type_lista *);
int elimina_elemento(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina_occorrenza(Lista, int, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina_ultimo(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina_testa(Lista, item_type_lista *);
int elimina_coda(Lista, item_type_lista *);
int assegna(Lista, int, item_type_lista *);
int modifica_elemento(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int modifica_occorrenza(Lista, int, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int modifica_ultimo(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int leggi(Lista, int, item_type_lista *);
int leggi_testa(Lista, item_type_lista *);
int leggi_coda(Lista, item_type_lista *);
int lista_vuota(Lista);
int lista_piena(Lista);
int lunghezza(Lista);
int stampa_lista(Lista, void (*s)(item_type_lista *));
int cerca_occorrenza(Lista, int, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int cerca(Lista, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int cerca_ultimo(Lista, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));

#endif

**unomichisiada** · 12-01-2006, 14:30

ora gli do uno sguardo

**unomichisiada** · 12-01-2006, 16:50

Ho modificato il tuo codice estrapolando solo le parti che hai indicato, il problema è che a me funziona perfettamente.Prova ad eseguire il codice sotto cambiando i valori di "da_cercare","da_modificare" e "nuovo elemento", ti renderai conto che funziona.Mi devi dire esattamente quali elementi devo inserire,in che ordine e la scelta che devo fare da menu perchè io possa riprodurre esattamente il problema. Comunque le funzioni sembrano corrette, il problema deve essere altrove, magari nell'acquisizione da tastiera

codice:

#include <stdio.h>
#include <stdlib.h>

#define item_type_lista float

typedef void * Lista;

Lista crea_lista(void);
int inserisci(Lista, int, item_type_lista *);
int inserisci_testa(Lista, item_type_lista *);
int inserisci_coda(Lista, item_type_lista *);
int inserimento_ordinato(Lista, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina(Lista, int, item_type_lista *);
int elimina_elemento(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina_occorrenza(Lista, int, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina_ultimo(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int elimina_testa(Lista, item_type_lista *);
int elimina_coda(Lista, item_type_lista *);
int assegna(Lista, int, item_type_lista *);
int modifica_elemento(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int modifica_occorrenza(Lista, int, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int modifica_ultimo(Lista, item_type_lista *, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int leggi(Lista, int, item_type_lista *);
int leggi_testa(Lista, item_type_lista *);
int leggi_coda(Lista, item_type_lista *);
int lista_vuota(Lista);
int lista_piena(Lista);
int lunghezza(Lista);
int stampa_lista(Lista, void (*s)(item_type_lista *));
int cerca_occorrenza(Lista, int, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int cerca(Lista, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
int cerca_ultimo(Lista, item_type_lista *, int (*c)(item_type_lista *, item_type_lista *));
void ottieni_elemento(item_type_lista *ritorno);
int compara(item_type_lista *uno, item_type_lista *due);
void stampa(item_type_lista *x);

int main()
{
  
  Lista L = crea_lista();
  float dati[] = {23,40,33,3,6,90,95,2,4,37,89};
  int i ;
  for(i = 0 ; i < 11 ; i++)
	  inserisci(L,i+1,&dati[i]);
  stampa_lista(L,stampa);
  float da_cercare = 4;
  int eliminato = cerca_occorrenza(L, 1, &da_cercare, compara);
  if (eliminato)
	  printf("Elemento trovato in posizione %d\n", eliminato);
	else 
		printf("Elemento NON trovato\n");

 float da_modificare =90;
 float nuovo_elemento = 4;
  eliminato = modifica_occorrenza(L, 1, &da_modificare, &nuovo_elemento, compara);
  if (eliminato) 
	  printf("Elemento modificato\n");
  else 
		printf("Elemento NON trovato\n");
  stampa_lista(L,stampa);
  return 0;
}


struct campo_lista {
  item_type_lista info;
  struct campo_lista *next, *prev;
};

typedef struct LISTA {
  struct campo_lista *Head, *Tail;
  unsigned lunghezza;
} *Lista_ls;

Lista crea_lista(void)
{
  Lista_ls l = (Lista_ls)malloc(sizeof(struct LISTA));
  l->lunghezza = 0;
  l->Head = l->Tail = NULL;
  return (Lista) l;
}
  

void stampa(item_type_lista *x)
{
  printf("%.2f\t", *x);
}

int compara(item_type_lista *uno, item_type_lista *due)
{
  return (int) (*uno - *due);
}


int inserisci(Lista L, int pos, item_type_lista *elemento)
{
  if (!lista_piena(L))
  {
    Lista_ls l = (Lista_ls) L;
    if (pos > 0 && pos <= l->lunghezza + 1)
    {
      struct campo_lista *nuovo = (struct campo_lista *)malloc(sizeof(struct campo_lista));
      if (nuovo != NULL)
      {
        nuovo->info = *elemento;
        if (pos == 1)
        {
          nuovo->prev = NULL;
	  nuovo->next = l->Head;
	  if (l->Head)
	    l->Head->prev = nuovo;
	  if (l->Tail == NULL)
	    l->Tail = nuovo;
	  l->Head = nuovo;
        }
        else if (pos == l->lunghezza + 1)
        {
	  nuovo->next = NULL;
	  nuovo->prev = l->Tail;
	  l->Tail->next = nuovo;
	  l->Tail = nuovo;
        }
        else if (pos == l->lunghezza)
        {
	  nuovo->next = l->Tail;
	  nuovo->prev = l->Tail->prev;
	  l->Tail->prev->next = nuovo;
	  l->Tail->prev = nuovo;
        }
        else
        {
	  struct campo_lista *temp = l->Head->next;
	  int i = 2;
	  while (i != pos)
	  {
	    temp = temp->next;
	    i++;
	  }
	  nuovo->next = temp;
	  nuovo->prev = temp->prev;
	  temp->prev->next = nuovo;
	  temp->prev = nuovo;
        }
        l->lunghezza++;
        return 1;
      }
    }
  }
  return 0;
}

int lista_piena(Lista L)
{
  return 0;
}


int leggi(Lista L, int pos, item_type_lista *ritorno)
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    if (pos > 0 && pos <= l->lunghezza)
    {
      if (pos == 1)
        *ritorno = l->Head->info;
      else if (pos == l->lunghezza)
        *ritorno = l->Tail->info;
      else
      {
        int i = 2;
        struct campo_lista *temp = l->Head->next;
        while (i++ != pos)
	  temp = temp->next;
        *ritorno = temp->info;
      }
      return 1;
    }
  }
  return 0;
}

int lunghezza(Lista L)
{
  Lista_ls l = (Lista_ls) L;
  return l->lunghezza;
}


int stampa_lista(Lista L, void (*stampa)(item_type_lista *))
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Head;
    while (temp)
    {
      (*stampa)(&(temp->info));
      temp = temp->next;
    }
    printf("\n");
    return 1;
  }
  return 0;
}



int assegna(Lista L, int pos, item_type_lista *el)
{
  item_type_lista temp;
  int eliminato = elimina(L, pos, &temp);
  if (eliminato)
    return inserisci(L, pos, el);
  return 0;
}
int elimina(Lista L, int pos, item_type_lista *ritorno)
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    if (pos > 0 && pos <= l->lunghezza)
    {
      struct campo_lista *temp = NULL;
      if (pos == 1)
      {
        *ritorno = l->Head->info;
        temp = l->Head;
        l->Head = l->Head->next;
        if (l->Head)
	  l->Head->prev = NULL;
        else
	  l->Tail = NULL;
        free(temp);
      }
      else if (pos == l->lunghezza)
      {
        *ritorno = l->Tail->info;
        temp = l->Tail;
        l->Tail = l->Tail->prev;
        l->Tail->next = NULL;
      }
      else
      {
        int i = 2;
        temp = l->Head->next;
        while (i++ != pos)
	  temp = temp->next;
        *ritorno = temp->info;
        temp->next->prev = temp->prev;
        temp->prev->next = temp->next;
        free(temp);
      }
      l->lunghezza--;
      return 1;
    }
  }
  return 0;
}




int cerca_occorrenza(Lista L, int occ, item_type_lista *el, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    Lista_ls l = (Lista_ls) L;
    struct campo_lista *temp = l->Head;
    int pos = 1;
    int occorrenza = 0;
    while (temp)
    {
      if ((*compare)(&temp->info, el) == 0)
	if (++occorrenza == occ)
	  return pos;
      pos++;
      temp = temp->next;
    }
  }
  return 0;
}
int lista_vuota(Lista L)
{
  Lista_ls l = (Lista_ls) L;
  return l->lunghezza == 0;
}
int modifica_occorrenza(Lista L, int occ, item_type_lista *vecchio, item_type_lista *nuovo, int (*compare)(item_type_lista *, item_type_lista *))
{
  if (!lista_vuota(L))
  {
    int pos = cerca_occorrenza(L, occ, vecchio, compare);
    printf("pos:\t%d\n", pos);
    if (pos)
      return assegna(L, pos, nuovo);
  }
  return 0;
}

**{Bl4d3}** · 12-01-2006, 17:02

allora, io non ho testato il tuo listato (al momento non mi è possibile).

Allora, fai questa prova con il mio main:
fai 6 inserimenti in code e inserisci nell'ordine:
1,2,3,1,2,3 (sono float)
Poi fa modifica_occorrenza: prova a modificare la seconda occorrenza di 2 e rimpiazzarla con 100 per esempio...
a me non va.

Discussione: [C] Funzione che richiama funzione e liste

Strumenti discussione

Ricerca discussione

Visualizza

[C] Funzione che richiama funzione

Permessi di invio