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;
};
0
Walter 20 ene. 2018 a las 15:28

3 respuestas

La mejor respuesta

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.

3
user2736738 20 ene. 2018 a las 12:46

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

-1
K.Vani 20 ene. 2018 a las 14:38

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 )
1
Vlad from Moscow 20 ene. 2018 a las 12:59