结构中的指针指向另一个结构

Question

I am trying to understand how pointers in linked lists work. So far i am having lots of trouble trying to figure out where the pointer is pointing to and how a pointer of a type struct works( I know we need to allocate memory from the heap but can't quite understand it, but maybe that's a different question altogether).

Lets take this structure:

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

What I think will happen now is:

1. Say you have a pointer of type Node in the main function, Node* p and this is allocated memory (using malloc).

2. Now if we have some data p->data=5; , p points to the beginning of this data (at least this is what i think is happening).

Where exactly does link point to?

So now, i come across this particular piece of code:

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

typedef struct List {
    Node* head;
    int number_of_nodes;
} List;

So this is complete chaos in my brain! .

Now in the structure List , what is head doing? What is it pointing to? And how would you create a linked list at all with these two lists??

I am really trying my level best to understand how linked lists work, but all the pointers make it too hard to keep track of. You might suggest i start with something simple and i did, and i have already mentioned how much i understand. But the head pointer in the second structure has completely thrown me off track!

It would make my life so much more easier if someone could help me explain it while keeping track of the pointers.

Answer 1

Where exactly does link point to?

link points to another object of the same type:

+------+------+     +------+------+     +------+------+
| data | link |---->| data | link |---->| data | link | ----> ...
+------+------+     +------+------+     +------+------+

Now in the structure List, what is head doing? What is it pointing to?

head points to the first node in a list:

+-----------------+     +------+------+     +------+------+ 
| head            |---->| data | link |---->| data | link |----> ...
+-----------------+     +------+------+     +------+------+
| number_of_nodes |
+-----------------+

I am really trying my level best to understand how linked lists work,

Don't feel bad - linked lists threw me for a loop in my Data Structures class (my first "hard" CS class). It took me a solid week longer than my classmates to grok the concept. Hopefully the pictures help.

Edit

what happens if you have a pointer to the structure List, memory allocated and all? Where does it point to then (according to the diagrams, which did help by the way)

So, let's assume you have the following code:

/**
 * Create a new list object.  head is initially NULL,
 * number_of_nodes initially 0.
 */
List *newList( void )
{
  List *l = malloc( sizeof *l );
  if ( l )
  {
    l->head = NULL;
    l->number_of_nodes = 0;
  }
  return l;
}

int main( void )
{
  List *l = newList();
  ...
}

Then your picture looks like this:

+---------+       +--------------------+
| l: addr | ----> | head: NULL         |
+---------+       +--------------------+
                  | number_of_nodes: 0 |
                  +--------------------+

( addr represents some arbitrary memory address)

Now let's say you add a node to your list:

/**
 * Create a new node object, using the input data
 * link is initially NULL
 */
Node *newNode( int data )
{
  Node *n = malloc( sizeof *n );
  if ( n )
  {
    n->data = data;
    n->link = NULL;
  }
  return n;
}

void insertNode( List *l, int data )
{
  Node *n = newNode( data );
  if ( n )
  {
    /**
     * If list is initially empty, make this new node the head
     * of the list.  Otherwise, add the new node to the end of the
     * list.
     */
    if ( !l->head ) // or n->head == NULL
    {
      l->head = n;
    }
    else
    {
      /**
       * cur initially points to the first element in the list.  
       * While the current element has a non-NULL link, follow
       * that link.
       */
      for ( Node *cur = l->head; cur->link != NULL; cur = cur->link )
        ; // empty loop body
      cur->link = n;
    }
    l->number_of_nodes++;
  }
}

int main( void )
{
  List *l = newList();
  insertNode( l, 5 );
  ...
}

Now your picture looks like this:

+---------+       +--------------------+      +------------+
| l: addr | ----> | head: addr         | ---> | data: 5    |
+---------+       +--------------------+      +------------+
                  | number_of_nodes: 1 |      | link: NULL |
                  +--------------------+      +------------+

You could add another node:

int main( void )
{
  List *l = newList();
  insertNode( l, 5 );
  insertNode( l, 3 );
  ...
}

then your picture becomes

+---------+       +--------------------+      +------------+        +------------+
| l: addr | ----> | head: addr         | ---> | data: 5    |   +--> | data: 3    |
+---------+       +--------------------+      +------------+   |    +------------+
                  | number_of_nodes: 2 |      | link: addr | --+    | link: NULL |
                  +--------------------+      +------------+        +------------+

Naturally, you'd want to add some error checking and messages in case a node couldn't be allocated (it happens). And you'd probably want an ordered list, where elements are inserted in order (ascending, descending, whatever). But this should give you a flavor of how to build lists.

You'd also need functions to remove items and free that memory. Here's how I'd free an entire list:

void freeList( List *l )
{
  Node *prev, *cur = l->head;
  while( cur && cur->link )
  {
    prev = cur;
    cur = cur->link;
    free( prev );
  }
  free( cur );
}

int main( void )
{
  List *l = newList();
  ...
  freeList( l );
  free( l );
  ...
}

Answer 2

… a pointer of a type struct…

A pointer cannot be of a type struct. A pointer can point to a structure.

C has objects. Objects include char , int , double , structures, and other things. A structure is a collection of objects grouped together.

In main, if you define p with Node *p; , you then have a pointer p . It has no value because you have not given it a value. When you execute p = malloc(sizeof *p); , you request enough memory for the size of the thing p points to ( *p ). If malloc returns a non-null pointer, then p points to a Node structure.

Then p->data refers to the data member of that structure. p->data is shorthand for (*p).data , in which *p means “the object p points to” and .data means “the data member in that object.”

After p = malloc(sizeof *p); and p->data = 5; , p->link does not point to anything because you have not assigned it a value. In a linked list, you would use malloc to get memory for another Node , and then you would set the p->link in one Node to point to the new Node . In each Node , its link member points to the next Node in the list. Except, in the last Node , p->link is set to a null pointer to indicate it is the last Node .

In List , you would set head to point to the first Node in a list of Node objects.