Thread: Pushing a new head to list - C

Hey.

This is the code of a list implementation and some function to remove duplicates in it.

I have small question about the two final lines in push function:
First, we define the next element of the new node as the former head - using de-reference.
And after that, we define the head to be equal to the address of the new node.

For me, it looks like a buggy circle somehow...

I see it so:
The next element of the new node is pointing to the former (about to be) head.
Now, this former head is being equal to new node.
So it seems like the new node's next at first points to the former head, and then this next is pointing to the new node (as we define *head to be equal to new node).

Eventually, I see it as if new node's next points to new node, instead of to the former head.

What am I missing here?

Thank you all!

Code:

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

typedef struct Node {
    int data;
    struct Node* next;
} Node;

void printList(Node *head) {
    Node* p = head;
    while (p !=NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
     printf("\n");
}

void push(Node** head, int new_data)
{
    Node* new_node = (Node*) malloc(sizeof(Node));
    new_node->data  = new_data;
    new_node->next = *head;
    *head = new_node;
}


void deleteList(Node** head) {
    Node* p = *head;
    while (p !=NULL) {
        Node *next = p->next;
        free(p);
        p = next;
    }
    *head = NULL;
}


void removeDuplicates(Node *head) {
    Node *ptr1, *ptr2;
    ptr1 = head;
 
    while (ptr1 != NULL ) {
        ptr2 = ptr1;
 
        while (ptr2->next != NULL) { // iterate the list from ptr2
        
            if (ptr1->data == ptr2->next->data) { // need to delete
                Node* tmp = ptr2->next;
                ptr2->next = ptr2->next->next;
                free(tmp);
            } else {
                ptr2 = ptr2->next;
            }
        }
        ptr1 = ptr1->next; // move to next node
    }
}


void myListTest() {
    Node* phead = NULL;
    for(int i=0; i<10; i++) { 
        push(&phead, i); 
        push(&phead, 10-i); 
    }
    printList(phead);
    removeDuplicates(phead);
    printList(phead);
    deleteList(&phead);
}
int main() {
    myListTest(); 
    return 0; 
}

Aren't you overthinking about pointers usage?

Code:

// FIX: Returns true if OK, false if allocation fail.
int push ( Node **head, int new_data )
{
  Node *new_node = malloc ( sizeof ( Node ) );

  // FIX: malloc() could fail!
  if ( ! new_node ) 
    return 0; // FAIL!

  new_node->data  = new_data;

  // *head, of course, holds the address of the head node!
  // Since the 'new_node' holds the address of the new node (duh!),
  // we have to assign the address of old 'head' to it's next member...
  new_node->next = *head;

  // ...and make this new_node the new head!
  *head = new_node;

  return 1; // SUCCESS!
}

Using you should do:

Code:

if ( ! push ( &head, i ) )
{
  fputs( "ERROR pushing data.\n", stderr );

  // Let crt0 get rid of allocated memory before exit...
  exit( EXIT_FAILURE );
}

@flp1969 - Sorry but I can't see how this answers my question at all...

Originally Posted by HelpMeC

@flp1969 - Sorry but I can't see how this answers my question at all...

Ok... your ONLY question: "What am I missing here?"
A: I think you aren't missing anything...

@flp1969 -
"For me, it looks like a buggy circle somehow...
Eventually, I see it as if new node's next points to new node, instead of to the former head."

@john.c - amazing.
I think I got it.
The key word here is: "reset".

And your simulation actually demonstrates that head is "reflected" differently as we go through the code.
It like makes a mark in each Node.

Thank you!!