在 C 中使用链表

Question

我正在学习 C 语言编程，但遇到了一些麻烦，尤其是在使用指针时。这对我来说有点困难，因为我们在 Java 或 C# 中不使用指针。

我尝试做的是创建一个链表（在互联网上找到的代码）并在其中推送元素。就像下面的代码一样。

发生的情况是，当我取消注释第二行代码时，代码有效，但我收到以下列表作为答案 {0, 1, 2}，即使我没有在列表中推送数字 0。我想将其作为答案：{1, 2}。

int main (){
    node_t * test_list = NULL;

    //test_list = malloc(sizeof(node_t));

    push(test_list, 1);
    push(test_list, 2);

    print_list(test_list);

    return 0;
}

代码如下所示：

typedef struct node
{
  int val;
  struct node * next;
}              node_t;

void print_list(node_t * head)
{
  node_t * current = head;

  while (current != NULL)
    {
      printf("%d\n", current->val);
      current = current->next;
    }
}

node_t* new_node(node_t * head)
{
  node_t * head2 = malloc(sizeof(node_t));

  return  head2;
}

void push(node_t * head, int val)
{
  if (head == NULL)
    {
      head = new_node(head);
      head->val = val;
      head->next = NULL;
    }
  else
    {
      node_t * current = head;
      while (current->next != NULL)
          current = current->next;

      /* now we can add a new variable */
      current->next = malloc(sizeof(node_t));
      current->next->val = val;
      current->next->next = NULL;
    }
}

在 push 函数中，我决定检查 head 是否等于 NULL。如果是这种情况，我只想创建一个新节点并将其分配给它。我不知道这是否是一个好方法。然而，它不起作用。

如果有人能引导我走上正确的道路，我将不胜感激！

谢谢！

（代码来源：http://www.learn-c.org/en/Linked_lists）

---

Answer 1

我将尝试解释额外元素 0。

test_list = malloc(sizeof(node_t)); //this changes the pointer test_list                
                                    //which is initially NULL to a non-NULL pointer, hence the mysterious extra element "0"

 push(test_list, 1);

void push(node_t * head, int val) {
if (head == NULL) //head is not NULL at this point because you called malloc earlier on it, so 1 will be inserted in the next position
{...}

你应该在 malloc 之后用一些值初始化列表的头部：

test_list = malloc(sizeof(node_t));


head->val = 5; //some value
head->next = NULL;

push(test_list, 1);
...

现在，第一个元素不会是 0，而是 5。

Answer 2

当您在代码中取消注释以下行时

//test_list = malloc(sizeof(node_t));

在这里，您在调用推送函数之前分配头指针。 所以，下面的代码行永远不会被执行

 if (head == NULL)
    {
        head = new_node(head);
        head->val = val;
        head->next = NULL;}

因为你已经为头指针分配了一次并且你还没有初始化它，然后是两个推送函数。因此，您将在列表中看到 0/garbage,1,2 而不是 1,2。

当您为 test_list 注释了 malloc 后，在下面的代码中

if (head == NULL)
    {
        head = new_node(head);
        head->val = val;
        head->next = NULL;
    }else
    {

        node_t * current = head;
        while (current->next != NULL) {
            current = current->next;
        }

由于您没有发送 test_list 的地址（&test_list-您需要使用双指针），所以对if case 中的头部所做的任何更改都不会反映在 test_list 中。

浏览链接以获得清晰的理解- linked_list

Answer 3

尝试以下功能。

node_t * new_node( int val )
{
    node_t * n = malloc( sizeof( node_t ) );

    if ( n )
    {
        n->val = val;
        n->next = NULL;
    }

    return  n;
}

void push( node_t **head, int val ) 
{
    node_t *n = new_node( val );

    if ( n )
    {
        while ( *head ) head = &( *head )->next;
        *head = n;
    }
}

函数推送必须像调用

push( &test_list, 1 );

至于您的函数push 实现，它处理test_list 的副本。所以test_list的原始值没有改变。

Answer 4

来自莫斯科的 Vlad 和 Violeta Marin 已经发布了它不起作用的原因。我对在您的代码中进行了一些更改以使其起作用，

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

  typedef struct node
  {
     int val;
     struct node * next;
  } node_t;

  void print_list(node_t * head) 
  {
      node_t * current = head;
      printf("called\n");
      while (current != NULL) {
         printf("%d\n", current->val);
         current = current->next;
      }
  }


  node_t* new_node()
  {
     //you have to return NULL , if malloc fails to allocate memory 
     node_t * head2 = malloc(sizeof(node_t));
     return  head2;
  }

  void push(node_t **head, int val)
  {
      if (*head == NULL)
      {
          printf("null\n");  
         //you have to check the return value of new_node
         (*head) = new_node();
         (*head)->val = val;
         (*head)->next = NULL;
      }
      else {
          printf("not null\n");
          node_t * current = *head;

          while (current->next != NULL) {
              current = current->next;
          }
          /* now we can add a new variable */
          //you have to check the return value of malloc
          current->next = malloc(sizeof(node_t));
          current->next->val = val;
          current->next->next = NULL;
       }
  }

  void my_free(node_t *head)
  {
    node_t *temp= NULL;
    while(head) 
    {
       temp=head->next;
       free(head);
       head=temp;
    }
}
int main ()
{
   node_t *test_list = NULL;
   push(&test_list, 1);
   push(&test_list, 2);
   print_list(test_list);
   my_free(test_list);
   return 0;
}

Answer 5

以下代码：

1) corrects several oversights in the posted code
2) works correctly
3) contains the logic that (generally) is always used to 
   add a node to the end of a linked list
4) demonstrates that to change the contents of a passed in pointer
   the simplest way is to pass '**' 
   and the caller passes the address of the pointer, not the contents of the pointer
5) uses consistent formatting
6) avoids unnecessary/misleading clutter/confusion in the definition of the struct
7) removes unnecessary parameters from functions
8) properly prototypes the functions 
   notice that the new_node() function prototype has '(void)'
   while the actual function body just has '()'

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

struct node
{
    int val;
    struct node * next;
};

// prototypes
void          print_list( struct node * head);
struct node * new_node( void );
void          push( struct node ** head, int val);


int main ( void )
{

    struct node * test_list = NULL;

    push(&test_list, 1);
    push(&test_list, 2);

    print_list(test_list);

    return 0;
} // end function: main


// step through linked list, printing the val field from each node
void print_list( struct node * head)
{
    struct node * current = head;

    while (current != NULL)
    {
        printf("%d\n", current->val);
        current = current->next;
    }
} // end function: print_list


// create a new node
struct node * new_node()
{
    struct node * head2 = NULL;

    if( NULL == (head2 = malloc(sizeof( struct node))))
    { // then malloc failed
        // handle error, cleanup, and exit
    }

    return  head2;
} // end function: new_node


// append a new node to end of linked list
// need to use '**' so actual pointer in main() will be updated
void push( struct node ** head, int val)
{
    struct node * current = NULL;

    if (*head == NULL)
    { // then list is empty
        current = new_node();
        current->val = val;
        current->next = NULL;
        *head = current;
    }

    else
    {
        current = *head;

        while (current->next != NULL)
        {
            current = current->next;
        }

        /* now we can append a new node to linked list */
        current->next = new_node();
        current->next->val = val;
        current->next->next = NULL;
    }
} // end function: push