没有 malloc 的 C 中的链表

Question

#include <stdio.h>

typedef struct node
{
      int i;
      struct node *next;
}node;

node getnode(int a)
{
      struct node n;
      n.i=a;
      n.next=NULL;
      return n;
}

main()
{
     int i;
     node newtemp,root,temp;

     scanf("%d",&i);
     root=getnode(i);
     temp=root;

     while(i--)
     {
         newtemp=getnode(i);

         temp.next=&newtemp;
         if(root.next==NULL)
         {
            root=temp;
         }
        temp=*(temp.next);
     }


     temp=root;

     while( temp.next != NULL )
     {
         printf(" %d ",temp.i);
         temp=*(temp.next);
     }
}

我试图在不使用 malloc 的情况下创建一个链表。编程只打印根，后面没有节点。我找不到错误。如果有任何内存问题，gcc 编译器会抛出一个分段错误。（？）请忽略糟糕的编程风格。

Answer 1

当你初始化temp.next时，你分配给它的指针的值是多少？

temp.next=&newtemp;

为什么，每次都是一样的！ （不服气的就画图吧。）

放弃。如果您需要不确定数量的内存（对于不确定数量的节点，您需要），那么您需要分配内存。

Answer 2

您可以避免 malloc 但不是免费的：

• 在 Linux/UNIX 上，您可以调用 brk() 并编写您自己的内存分配器。
• 在每个系统上，您都可以使用固定大小的数组作为内存源来编写自己的分配器。
• 我看不出有什么替代品可以直接通过 malloc/free 购买。他们在那里是有原因的。
• 返回要在外部使用的局部变量很简单，但会出错并且不起作用。

Answer 3

您只有两个内存空间可用于存储节点，它们是root 和newtemp。当您将新节点分配给 newtemp 时，旧节点不再存在。

假设您在 scanf 中输入了数字 5，在循环的第一次迭代之前，您有：

5 -> NULL

在循环的第一次迭代之后，您有

5 -> 4 -> NULL

在循环的第二次迭代之后，您有

5 -> 3 -> NULL

（包含4 的节点已完全替换为包含3 的节点）。

唯一的解决方案是使用malloc，并使getnode返回node*。

Answer 4

您可以静态声明节点结构数组并从该数组中选择新节点。但是你会实现一个蹩脚的、可悲的专业定制分配器。可用节点的最大数量将是该数组的大小。

或者，您可以使用递归作为分配机制，并对递归堆栈底部的列表进行操作。

这两种方法都差不多。

Answer 5

当然，您可以构建链表或任何其他没有动态内存分配的数据结构。 但是，无论您多么努力，您都无法完全不分配内存来构建它。

选择：

创建一个全局或静态内存池，您可以在其中放置对象，模仿堆/malloc/free。 FreeRTOS 做了类似的事情。 在这种情况下，您将在程序开始时静态分配一个大内存块和将负责管理它，在需要新节点时返回正确的指针并将该内存标记为已使用。

P.S.：我不会质疑你为什么要避免使用 malloc。我想你有一个很好的理由。

在你的程序中，当你这样做时，在第 20 行：

     node newtemp,root,temp; 

您正在分配三个节点，其中之一是“newtemp”。 然后你在第 28 行做：

     newtemp=getnode(i); 

这只是副本返回节点的内容覆盖旧的“newnode”（有争议，不是吗？）

所以你这样做，只是吼叫：

     temp.next=&newtemp; 

这设置了一个指针，该指针最初来自“root.next”到您的“newnode”。

     if(root.next==NULL) 

第一次通过时将为“NULL”，但随后仅替换相同的内容。

    temp=*(temp.next); 
     { 
        root=temp; 
     } 

又是复制从单个分配对象“*(temp.next)”到另一个对象“temp”的数据。 它不会创建任何新节点。

如果您这样做，它将起作用：

#include <stdio.h>

typedef struct node 
{ 
    int i; 
    struct node *next; 
}
    node; 

#define MAX_NODES   10

node    *create_node( int a )
{ 
    // Memory space to put your nodes. Note that is is just a MAX_NODES * sizeof( node ) memory array.
    static node node_pool[ MAX_NODES ];
    static int  next_node = 0;

    printf( "[node  *create_node( int a )]
	next_node = %d; i = %d
", next_node, a );
    if ( next_node >= MAX_NODES )
    {
        printf( "Out of memory!
" );
        return ( node * )NULL;
    }

    node    *n = &( node_pool[ next_node++ ] );

    n->i = a;
    n->next = NULL;

    return n; 
} 

int main( )
{ 
    int i; 
    node    *newtemp, *root, *temp; 

    root = create_node( 0 ); 
    temp = root; 

    for ( i = 1; ( newtemp = create_node( i ) ) && i < MAX_NODES; ++i )
    { 
        temp->next = newtemp; 

        if ( newtemp )
        {
            printf( "temp->i = %d
", temp->i );
            printf( "temp->next->i = %d
", temp->next->i );
            temp = temp->next;
        }
    }


    for ( temp = root; temp != NULL; temp = temp->next )
        printf( " %d ", temp->i );

    return  0;
}

输出：

    $ gcc -Wall -o list_no_malloc list_no_malloc.c 

$ ./list_no_malloc
[node   next_node = 0; i = 0)]
[node   next_node = 1; i = 1)]
temp->i = 0
temp->next->i = 1
[node   next_node = 2; i = 2)]
temp->i = 1
temp->next->i = 2
[node   next_node = 3; i = 3)]
temp->i = 2
temp->next->i = 3
[node   next_node = 4; i = 4)]
temp->i = 3
temp->next->i = 4
[node   next_node = 5; i = 5)]
temp->i = 4
temp->next->i = 5
[node   next_node = 6; i = 6)]
temp->i = 5
temp->next->i = 6
[node   next_node = 7; i = 7)]
temp->i = 6
temp->next->i = 7
[node   next_node = 8; i = 8)]
temp->i = 7
temp->next->i = 8
[node   next_node = 9; i = 9)]
temp->i = 8
temp->next->i = 9
[node   next_node = 10; i = 10
Out of memory!
 0  1  2  3  4  5  6  7  8  9 

Answer 6

链表是不确定长度的东西，没有 malloc 就不能创建任何不确定长度的东西。

我建议您简单地使用 malloc 来分配链中的下一个链接。

Answer 7

使用 malloc 时，指向该位置的“指针”将传递给变量（这是一个指针）。

node* new = (node*)malloc(sizeof(node));

每次使用此代码时，都会指向一个“新”位置。相反，您使用的是普通变量，这些变量具有“静态”分配的内存。这意味着，无论何时您提到“temp”或“newtemp”，您每次都指的是同一个位置。

现在你告诉我如何仅使用 3 个（root、temp、newtemp）内存位置来存储 10 个元素的长列表。你可能想画出内存位置来想象正在发生的事情。但请记住，每次您调用“temp”时，它都是相同的内存位置。为此，我们必须使用 malloc（或 calloc）来动态分配内存。

在那种情况下，我们可以用很少的指针来凑合（远小于列表使用的内存）。

Answer 8

由于还没有人本着现代 C（又名 C99）的精神回答这个关于 malloc 部分的问题。如果您的编译器符合您的要求变长数组:

node myNodes[n];

其中 n 具有一些仅在运行时确定的值。你可能不应该用这种方法过度使用它，因为它受限于堆栈的大小，否则你可能会遇到计算器溢出。