Thread: I need help to delete new node

My list contain with three nodes I want to delete new node. I do not understand how to delete new node

I want this output 123 13

Code:

#include<stdio.h>

#include<stdlib.h>


typedef struct node
{
    int n;
    struct node *next;
}node;

int main()
{
 node *current = NULL;
 node *new = NULL;
 node *last = NULL;
 
 node *head = NULL;
 
 current = malloc(sizeof(current));
 new = malloc(sizeof(new));
 last = malloc(sizeof(last));
 
   if (current == NULL)
       printf ("Memory not Allocated \n");
   else 
       printf ("Memory Allocated \n");
       current->n = 1;
       current->next = new;
       new->n = 2;
       new->next= last;
       last->n = 3;
       last->next= NULL;
       
       free(new);
       
       for (head = current; head != NULL; head = head->next)
           {
               printf("%d\n", head->n);
           } 

     return 0;
}

output
14090432
14104256
14093800
14095320

garbage value

Your problem is that you aren't setting head to point to the head of the linked list.

I suggest that you restrict yourself to having three node pointers: head, tail, and current. head points to the start node of the linked list, or is a null pointer if the linked list is empty. tail points to the end node of the linked list, or is a null pointer if the linked list is empty. current is used to iterate over the linked list, i.e., instead of changing head, you set current to head then change current to go to the next node. To build the linked list, you update head and tail in order to append the three nodes. (I'm assuming that you want to append, which is why I suggest having tail; if you only want to prepend, just having head will do.)

That said, if you're going to delete the newest node before printing the linked list, why create it in the first place?

Are you all doing the same course? If there are only 3 nodes you'd be better off using an array. Or, if you want to simulate a linked list just do:

Code:

#include <stdio.h>

typedef struct node {
    int n;
    struct node *next;
} node;

int main(void)
{
    node list[] = {
        { 1, &list[1] },    /* head */
        { 2, &list[2] },    /* silly */
        { 3, NULL }         /* tail */
    };
        
    for (node *curr = list; curr; curr = curr->next) {
        printf("%d\n", curr->n);
    }
    
    return 0;
}

Not much point in doing that though except to, perhaps, see how linked lists work

I guess what I'm saying is that unless you're using functions to construct the list there is essentially no point in having a linked list. By the way, in your version you're not freeing the memory you allocated using malloc(), so that's a problem

Or, if you want to be really cunning

Code:

#include <stdio.h>

typedef struct node {
    int n;
    struct node *next;
} node;

int main(void)
{
    node list[] = { { 1, &list[2] }, { 3, NULL }, { 2, &list[1] } };
        
    for (node *curr = list; curr; curr = curr->next)
        printf("%d\n", curr->n);
    
    return 0;
}

This is wrong:

Code:

Head = malloc(sizeof(Head));

It should have been:

Code:

Head = malloc(sizeof(*Head));

Originally Posted by Player777

okay but compiler is not showing warning /error

It's a logic error. In theory, static analysis can uncover that particular kind of logic error because that particular argument to malloc happens to be determined at compile time, but compilers don't usually do enough static analysis to be able to detect that, so what could happen in practice is that you allocate enough space for a pointer, and then you get a segmentation fault or something when you try to write an entire object to the space allocated and end up writing beyond the memory allocated.

Originally Posted by Player777

Exactly that was my plan That's why I'm asking all operation in the main

I know that the pointer has to be free to delete the node but I am not able to delete the node even on paper

You have to 1) find the node you want to delete (call it target) and at the same time keep track of the node previous to the target (call it prev); 2) change the previous node's next pointer to point to the the target node's next (e.g. prev->next = target->next); 3) at this point the target node is out of the list (nothing is pointing to target anymore) and you can free its memory. You'll have to handle the special case of target being the first (or only) node in the list

Personally I think that it's actually easier using functions than doing it all in main

What book are you using? Surely it has pictures of this