使用malloc()创建Linked List：节点内存分配与->运算符的技术咨询

Hey there! Let's break this down step by step since you already grasp the core concepts of linked lists and malloc()—that's a great foundation to build on.

1. First, Define Your Node Structure #

Before you can allocate memory for nodes, you need a blueprint for what a node is. In C, we use a struct to define this: each node holds your integer data and a pointer to the next node in the list.

typedef struct Node {
    int data;          // The integer value stored in the node
    struct Node* next; // Pointer to the next node (or NULL if it's the last)
} Node;

The typedef lets us use Node as a shorthand for struct Node, making the code cleaner.

2. Using malloc() to Allocate Memory for Nodes #

malloc() reserves a block of memory on the heap equal to the size you specify. For a node, you need enough space to hold both the int and the pointer—so we use sizeof(Node) to get that exact size.

Here's how to create a single node:

Node* new_node = (Node*)malloc(sizeof(Node));

• malloc(sizeof(Node)) returns a generic void* pointer, so we cast it to Node* to tell the compiler it points to our node structure.
• Always check if malloc() fails (it returns NULL if there's no memory left):

  if (new_node == NULL) {
      fprintf(stderr, "Oops! Couldn't allocate memory for the node.\n");
      exit(EXIT_FAILURE); // Exit the program if allocation fails
  }
  

3. What Does the -> Operator Do? #

The -> operator is a shorthand for accessing members of a struct through a pointer. Let's compare it to the . operator (used for struct variables):

• If you have a struct variable:

  Node my_node;
  my_node.data = 5; // Use . to access the data member
  

• If you have a pointer to a struct (like the new_node we just created):

  new_node->data = 5; // Equivalent to (*new_node).data = 5;
  

-> saves you from having to explicitly dereference the pointer with * every time you want to access a struct member—it's just a cleaner way to write the same thing.

4. Putting It All Together: Building Your 10-Node Linked List #

Now let's combine these pieces to create your list. We'll use a tail pointer to keep track of the last node, so we don't have to traverse the entire list every time we add a new node.

Here's a complete, working example:

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

// Define the node structure
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// Helper function to create a new node with given data
Node* create_node(int data) {
    Node* new_node = (Node*)malloc(sizeof(Node));
    if (new_node == NULL) {
        fprintf(stderr, "Memory allocation failed!\n");
        exit(EXIT_FAILURE);
    }
    new_node->data = data;
    new_node->next = NULL; // New node starts with no next node
    return new_node;
}

// Helper function to print the linked list
void print_list(Node* head) {
    Node* current = head;
    while (current != NULL) {
        printf("%d -> ", current->data);
        current = current->next;
    }
    printf("NULL\n");
}

// Helper function to free all memory used by the list
void free_list(Node* head) {
    Node* temp;
    while (head != NULL) {
        temp = head;
        head = head->next;
        free(temp); // Free each node one by one
    }
}

int main() {
    // Seed the random number generator for 1-10 values
    srand(time(NULL));

    Node* head = NULL; // Start with an empty list
    Node* tail = NULL; // Track the last node for easy linking

    // Create 10 nodes
    for (int i = 0; i < 10; i++) {
        // Generate a random integer between 1 and 10
        int random_data = (rand() % 10) + 1;
        Node* new_node = create_node(random_data);

        if (head == NULL) {
            // First node becomes both head and tail
            head = new_node;
            tail = new_node;
        } else {
            // Link the new node to the end of the list
            tail->next = new_node;
            tail = new_node; // Update tail to the new last node
        }
    }

    // Print the list to verify it works
    printf("Your linked list:\n");
    print_list(head);

    // Always free the memory to avoid leaks!
    free_list(head);

    return 0;
}

Key Notes on the Example: #

• We use srand(time(NULL)) to generate different random values each time the program runs.
• The create_node function encapsulates the memory allocation and node setup, making the main code cleaner.
• The free_list function is crucial—if you don't free the nodes, you'll leave memory allocated on the heap (a memory leak).

内容的提问来源于stack exchange，提问作者Ollie Parsons