好的，这个问题对于菜鸟程序员可能听起来很愚蠢。但是，这个问题真的让我困扰，我希望能得到一个充分的解答。我刚刚开始学习数据结构课程，以下是让我困扰的问题：
假设使用C语言，
//Implementing a node
struct Node
{
int data;
struct *Node;
};
struct Node N1;
//First node - actually second where !st Node is assumed to be Head.
struct Node *Head = &N1;
struct Node N2;
N2.(*Node) = &N1;
我的代码可能有些错误，因为我只是一个初学者，对C语言不是很熟悉。但是现在你可能已经理解了我想表达的基本意思。为什么不创建Node类型的变量，并将它们存储在Node类型的数组中以分配内存给新节点，而要涉及到动态内存分配的复杂性呢？
首先，你在声明结构体时有错误。 struct * 本身并不表示一种类型。你必须给出完整的类型名称：
struct Node
{
int data;
struct Node *Node;
};
您可以像上面那样使用局部变量来创建链表，但这会限制您的链表元素数量，即只有您显式声明的元素。这也意味着您无法在函数中创建链表，因为那些变量会超出其作用域。
例如，如果您这样做：
struct Node *getList()
{
struct Node head, node1, node2, node3;
head.Node = &node1;
node1.Node = &node2;
node2.Node = &node3;
node3.Node = NULL;
return &head;
}
如果您只能使用固定大小的数组，那么列表的长度将被限制在4个元素以内。如果您需要成千上万个元素怎么办？而且，通过返回局部变量的地址，当函数返回时它们超出了范围，访问它们会导致未定义行为。
通过动态分配每个节点，您只受可用内存的限制。
以下是使用动态内存分配的示例：
struct Node *getList()
{
struct Node *head, *current;
head = NULL;
current = NULL;
// open file
while (/* file has data */) {
int data = /* read data from file */
if (head == NULL) { // list is empty, so create head node
head = malloc(sizeof(struct Node *));
current = head;
} else { // create new element at end of list
current->next = malloc(sizeof(struct Node *));
current = current->next;
}
current->data = data;
current->Node = NULL;
}
// close file
return head;
}
malloc，但是在你做所有这些的过程中，你只是越来越接近编写自己的版本malloc，而不是坚持现有的动态版本。这里有一些使用动态内存的好理由
当你声明节点 struct Node N1; 时，该节点将存储在堆栈内存中。在节点范围之后，它将自动销毁。但是，在动态内存中，你需要在完成后释放内存。
当你有一些内存限制时。
当你不知道数组大小时，动态内存分配将会帮助你。
一个问题可能是您无法使用另一个函数向列表添加新节点。
请记住，自动变量（例如由struct Node node100;创建的变量）仅在定义它们的函数内部具有作用域。因此，当您执行以下操作时：
int main()
{
struct Node *head;
/* Some code there you build list as:
head ---> node1 ---> node2 --> .. ---> node99
*/
/* Add a new node using add_node function */
add_node(head, 555);
/* Access the last node*/
}
void add_node(struct Node *head, int val)
{
/* Create new node WITHOUT using malloc */
struct Node new_node;
new_node.data = val;
/* add this node to end of the list */
/* code to add this node to the end of list */
/* last_element_of_list.next = &new_node*/
return;
}
现在你认为已经将一个新节点添加到了列表的末尾。但是，不幸的是，它的生命周期在add_node函数返回时就结束了。当你尝试在main函数中访问最后一个节点时，程序会崩溃。
因此，为了避免这种情况，你需要将所有代码放在一个单一的函数中，以便这些节点的生命周期不会结束。
将所有代码放在一个函数中是不好的实践，会导致许多困难。
这是需要动态内存分配的一种情况，因为使用malloc分配的节点将在使用free释放之前一直存在，并且你可以将执行不同任务的代码放在不同的函数中，这是一个好的实践。
创建链表时不一定需要使用动态内存，但绝对不要为每个节点创建单独的变量。如果您想要存储多达N个项目，则需要声明N个不同的变量，当N变大时，这将变得非常麻烦。使用链表的整个思想是它可以根据需要增长或缩小；它是一种动态数据结构，因此即使您不使用malloc和free，您最终会做类似的事情。
例如，您可以在文件作用域中创建一个节点数组，如下所示：
struct node {
int data;
struct node *next;
};
/**
* use the static keyword to keep the names from being visible
* to other translation units
*/
static struct node store[N]; /* our "heap" */
static struct node *avail; /* will point to first available node in store */
你需要初始化数组，使每个元素都指向下一个元素，最后一个元素则指向NULL：
void initAvail( void )
{
for ( size_t i = 0; i < N - 1; i++ )
store[i].next = &store[i + 1];
store[N - 1].next = NULL;
avail = store;
}
avail指向并更新avail以指向下一个可用节点（如果avail为NULL，则没有更多可用节点）。struct node *getNewNode( void )
{
struct node *newNode = NULL;
if ( avail ) /* if the available list isn't empty */
{
newNode = avail; /* grab first available node */
avail = avail->next; /* set avail to point to next available node */
newNode->next = NULL; /* sever newNode from available list, */
} /* which we do *after* we update avail */
/* work it out on paper to understand why */
return newNode;
}
void freeNode( struct node *n )
{
n->next = avail;
avail = n;
}
struct node{
int a;
struct node* nextNode;
};
int main()
{
struct node head,node1,node2;
head.a=45;
node1.a=98;
node2.a=3;
head.nextNode=&node1;
node1.nextNode=&node2;
node2.nextNode=NULL;
if(head.nextNode== NULL)
{
printf("List is empty");
}
struct node* ptr=&head;
while(ptr!=NULL)
{
printf("%d ",ptr->a);
ptr=ptr->nextNode;
}
}