Estoy tratando de escribir una función que inserte el nodo al final de la lista.
El problema es que el puntero del último nodo de la lista no apunta a NULL y si muestro la lista obtengo un error del sistema.
struct node{
int value;
struct node *next;
};
struct node *AddToList (struct node *list, int n);
int main()
{
struct node *node;
node = AddToList(node, 30);
node = AddToList(node, 20);
node = AddToList(node, 10);
showlist(node);
return 0;
}
struct node *AddToList (struct node *list, int n){
struct node *new_node;
new_node=malloc(sizeof(struct node));
new_node->value=n;
new_node->next=list;
return new_node;
};
3 respuestas
Sí, eso se debe a que el primer nodo que inserta es next es no que tiene el valor NULL.
struct node *node = NULL; //<------
node = AddToList(node, 30);
node = AddToList(node, 20);
node = AddToList(node, 10);
showlist(node);
Esto solucionará el problema. Ahora, como resultado de hacer esto, la primera vez que inserte el nodo, se le asignará el valor next a next. Porque para la primera llamada a AddToList el list es NULL.
La forma en que lo hizo: node contenía un valor indeterminado (valor de basura) (node es una variable con duración de almacenamiento automático) y luego se agrega como link al primer nodo. Esto no tiene ningún uso práctico porque ahora no puede recorrer la lista pensando que encontrará un valor NULL que es cuando debe detenerse.
Del capítulo estándar §6.7.9
Si un objeto que tiene una duración de almacenamiento automático no se inicializa explícitamente, su valor es indeterminado.
Debe verificar el valor de retorno de malloc. En caso de que falle, debe manejar ese caso. Y libere la memoria asignada dinámicamente cuando haya terminado de trabajar con ella.
Tampoco estoy seguro de cómo trató de mostrar la lista, pero si es con la suposición de que el último nodo apuntará a NULL y luego comenzó a recorrerlo, entonces se ha ganado un comportamiento Indefinido en su código.
Cuando el usuario desea agregar un nodo en la última primera verificación, si es una lista vacía, si es así, agregue el nuevo nodo como nodo principal. Si la lista no está vacía, recorra la lista y descubra el último nodo marcando tp-> siguiente = NULL luego almacena la dirección del nuevo nodo en tp-> next y crea el siguiente campo del nuevo nodo con NULL. El siguiente programa muestra el concepto claramente
#include<stdio.h>
#include<malloc.h>
int item,count,pos;
struct node
{
int info;
struct node *next;
}*head,*tp;
void traversal()
{
if(head==NULL)
printf("\n List is empty");
else
{
tp=head;
while(tp->next!=NULL)
{
printf("\n%d",tp->info);
tp=tp->next;
}
printf("\n%d",tp->info);
}
}
void insertlast()
{
struct node *temp;
temp=(struct node*) malloc(sizeof(temp));
printf("\nEnter the element:");
scanf("%d",&item);
temp->info=item;
temp->next=NULL;
if(head==NULL)
head=temp;
else
{
tp=head;
while(tp->next!=NULL)
{
tp=tp->next;
}
tp->next=temp;
}
}
int main()
{
printf("\n\t\t**********SINGLY LINKED LIST********");
printf("\n\t------------------------------------------------------");
printf("\n\tInsertion last:");
printf("\n\t---------------------");
insertlast();
traversal();
printf("\n\tInsertion last:");
printf("\n\t---------------------");
insertlast();
traversal();
printf("\n\n\tInsertion last:");
printf("\n\t---------------------");
insertlast();
traversal();
printf("\n\n\tInsertion last:");
printf("\n\t---------------------");
insertlast();
traversal();
return 0;
}
Salida
**********SINGLY LINKED LIST********
------------------------------------------------------
Insertion last:
---------------------
Enter the element:12
12
Insertion last:
---------------------
Enter the element:13
12
13
Insertion last:
---------------------
Enter the element:14
12
13
14
Insertion last:
---------------------
Enter the element:15
12
13
14
15
Espero que lo entiendas. Gracias
Estoy tratando de escribir una función que inserte el nodo al final de la lista.
Esta función
struct node *AddToList (struct node *list, int n){
struct node *new_node;
new_node=malloc(sizeof(struct node));
new_node->value=n;
new_node->next=list;
return new_node;
};
No inserta un nodo al final de la lista. Inserta un nodo al comienzo de la lista antes del nodo principal.
La función que inserta un nodo al final de la lista puede verse de la siguiente manera.
int AddToList ( struct node **list, int n )
{
struct node *new_node = malloc( sizeof( struct node ) );
int success = new_node != NULL;
if ( success )
{
new_node->value = n;
new_node->next = NULL;
while ( *list != NULL ) list = &( *list )->next;
*list = new_node;
}
return success;
}
Y la función se puede llamar como
struct node *head = NULL;
AddToList( &head, 10);
AddToList( &head, 20);
AddToList( &head, 30);
Si desea que el orden de los valores de la lista sea 10, 20, 30.
El problema es que el puntero del último nodo de la lista no apunta a NULL
Porque se insertan nuevos nodos antes del primer nodo que no se inicializó
struct node *node;
Y por lo tanto tiene un valor indeterminado, el último nodo de la lista no apunta a NULL.
Debe establecer el puntero inicial en NULL.
struct node *node = NULL;
Tenga en cuenta que de acuerdo con el Estándar C, la función main sin parámetros se declarará como
int main( void )
Preguntas relacionadas
Nuevas preguntas
c
C es un lenguaje de programación de uso general utilizado para la programación del sistema (SO e integrado), bibliotecas, juegos y multiplataforma. Esta etiqueta debe usarse con preguntas generales sobre el lenguaje C, como se define en el estándar ISO 9899 (la última versión, 9899: 2018, a menos que se especifique lo contrario; también etiquete las solicitudes específicas de la versión con c89, c99, c11, etc.). C es distinto de C ++ y no debe combinarse con la etiqueta C ++ en ausencia de una razón racional.