Elimare elemento di una lista

di Anonimizzato12372 il
13 risposte
/
Anonimizzato12372
Utente anonimizzato
Ragazzi scusate è possibile implementare una funzione void che elimini un elemento da una lista doppiamente puntata?

13 Risposte

  • /
    Anonimizzato14574
    Utente anonimizzato
    Certo... è solo questa la domanda?

    per funzione void intendi una funzione del genere penso:
    void Nome_Funzione(*Lista,posizione_Elemento);
  • /
    Anonimizzato12372
    Utente anonimizzato
    Ho provato a implementare un algoritmo ma quando mando la stampa,dopo aver effettuato la cancellazione va in loop

    definizione lista: 
    
struct elemento{
struct elemento *next;
struct elemento *prec;
int x;
};
    funzioni: 
    
struct elemento *crea(){
   struct elemento *p,*punt=NULL;
   int i,n;
   printf("specificare il numero di elementi\n");
   scanf("%d",&n);
   if(n==0)
       p=NULL;
   else{
      p=(struct elemento *)malloc(sizeof(struct elemento));
      printf("inserisci il valore\n");
      scanf("%d",&p->x);
      punt=p;
      p->prec=NULL;
      for(i=2;i<=n;i++){
         punt->next=(struct elemento *)malloc(sizeof(struct elemento));
         punt->next->prec=punt;
         punt=punt->next;
         printf("inserisci l'elemento %d\n",i);
         scanf("%d",&punt->x);
      }
      punt->next=NULL;
   }
   return p;
}


void stampa(struct elemento *top){
if(top!=NULL){
    printf("%d",top->x);
    stampa(top->next);
}
}

struct elemento * togli_numero(struct elemento *top,int x){
   if(top!=NULL){
    if(top->x==x){
       struct elementi *res=NULL;
       res=top->next;
       free(top);
       top=res;
    }
    else
    top->next=togli_numero(top->next,x);
   }
   return top;
}
    main:
    
int main()
{
    struct elemento *top=NULL;
    struct elemento *top2=NULL;
    top=crea();
    stampa(top);
    top=togli_numero(top,3);
    stampa(top);
    return 0;
}
    sai dirmi dove sbaglio?
  • /
    Anonimizzato13826
    Utente anonimizzato
    Per togliere un elemento:

    Elemento *e = elemento da togliere;
    Elemento *p, *n;

    P= e->precedente;
    N= e->successivo;

    P->successivo = n;
    N->precedente = p;

    free(e);




    Per cercarlo:

    If(lista){
    Elemento e = lista;

    while(e!=NULL && e->valore!=valore_cercato)
    e=e->successivo;

    if(e){
    Rimuovi elemento ();

    return true;
    }

    return false;
    }
  • /
    Anonimizzato12372
    Utente anonimizzato
    Quindi devo fare un algoritmo iterativo non ricorsivo,grazie comunque per la risposta.
  • /
    Anonimizzato12372
    Utente anonimizzato
    Scusa ho provato l'algoritmo mettendo l'elemento da cancellare a inizio e fine lista e in questi due casi da segmentation fault
  • /
    Anonimizzato7887
    Utente anonimizzato

    antonx ha scritto:

    scusa ho provato l'algoritmo mettendo l'elemento da cancellare a inizio e fine lista e in questi due casi da segmentation fault
    Ciao,
    se l'elemento è il primo della lista allora restituisci il puntatore al secondo (cioè il next del primo) e fai una free sulla vecchia testa della lista.

    Se l'elemento da eliminare è l'ultimo allora significa che il suo successivo è NULL, quindi non dovrebbero esserci problemi: il next del penultimo diventa NULL e fai free su quello che prima era l'ultimo. Ricordati in ogni caso di restituire un puntatore alla testa della lista.
  • /
    Anonimizzato12372
    Utente anonimizzato
    La funzione dovrebbe essere di tipo void quindi non può restituire niente
  • /
    Anonimizzato7887
    Utente anonimizzato
    Tu l'avevi postata così:
    struct elemento * togli_numero(struct elemento *top,int x)
    Basta capirsi...
  • /
    Anonimizzato12372
    Utente anonimizzato
    Lo so ma purtroppo cosi non va bene infatti all'inizio ho scritto si può scrivere una funzione che cancella un elemento della lista senza ritornare niente
  • /
    Anonimizzato7887
    Utente anonimizzato
    Beh allora vorrà dire che il puntatore alla testa lo "assegnerai" a quello passato come parametro alla funzione (il tuo "top").
    Anche se mi sembra un po' meno naturale, non dovrebbe avere particolari problemi.
  • /
    Anonimizzato12372
    Utente anonimizzato
    Scusami non ho capito bene quello che vuoi dire
  • /
    Anonimizzato7887
    Utente anonimizzato
    Ho scritto velocemente un esempio relativo all'inserimento in coda:
    
#include <stdio.h>
#include <stdlib.h>

typedef struct elemento_t
{
	int val;
	struct elemento_t *next;
} Elemento;

typedef Elemento* Lista;

/* La funzione prende come parametro un puntatore alla lista:
 * può modificare la lista stessa! */
void inserisci_coda(Lista *l, int x)
{
	/* allocazione di un nuovo elemento della lista */
	Elemento *new_el = (Elemento *) malloc(sizeof(Elemento));
	new_el -> val = x;
	new_el -> next = NULL;
	
	/* se la lista è vuota */
	if(*l == NULL)
	{
		*l = new_el;
	}
	
	else
	{	
		Lista aux = *l;
		/* scorro fino in fondo */
		while(aux->next != NULL)
			aux = aux->next;
		
		aux->next = new_el;
	}
}


void stampa_lista(Lista l)
{
	while(l != NULL)
	{
		printf("%d\n", l->val);
		l = l->next;
	}
}


int main()
{
	Lista l;
	
	inserisci_coda(&l, 5);
	inserisci_coda(&l, 2);
	inserisci_coda(&l, 1);
	stampa_lista(l);

	return 0;
}
    A te il compito di adattarlo per l'eliminazione di un elemento.
  • /
    Anonimizzato12372
    Utente anonimizzato
    Va bene grazie appena posso ti mostrerò i risultati
Devi accedere o registrarti per scrivere nel forum
13 risposte