Question

我在理解链接列表时遇到很大问题，如果有人能解释以下内容，我将非常感激。

Element_t *pushfront(Element_t *list)
{ 
if(list==0)
return allocate();

list->prev=allocate();

list->prev->next=list;

list=list->prev;

return list;
}

这意味着list->prev->next=list？

这意味着什么：f->next->prev=f->prev？

我知道这只是程序代码的一部分，但我希望有人可以给我这些最简单的一般意义吗？

Answer 1

以下是带有注释的代码，它会告诉您发生了什么。

Element_t *pushfront(Element_t *list)
{ 
if(list==0) // If the list is emtpy
return allocate(); /* then you simply create a new node, which 
represents your list and return it. The size of your list grew from 0 to 1.*/

list->prev=allocate(); /*If the list is not empty, you add a new node by creating it,
and then the prev pointer of the first element in the list (list->prev) 
is set to this new element, as you want it to be first.*/

list->prev->next=list; /*Then you need to set the next pointer 
to the element you just added. The new element is at list->prev, 
so by list->prev->next, you just say, that the next element of the one
 you just created is the element that was first before you added the new one*/

list=list->prev; /* Here you just set the new element as the head of the list*/

return list; /*And here you return the new list*/
}

请注意，您的列表总是作为指向第一个元素的指针传递，因为这就是您所需要的。然后，您可以通过next指针访问所有元素，该指针是为列表中的每个元素设置的。

Answer 2

首先，链表与指针相互链接。它们实际上并不是按顺序存在的。

让我谈谈你的问题-1 list->prev->next=list; 在这里，您将前一个节点与当前节点链接。此代码表示将前一个链接链接到当前节点。然后，前一个节点现在与结构中定义的下一个指针链接。得到问题-2 f->next->prev=f->prev; 我不知道这是在哪里定义的，但在这里你正在做一个带圆圈的链表。此代码链接到第一个节点的最后一个节点。

Answer 3

该列表包含引用上一个节点和列表中下一个节点的节点。

该函数获取列表的第一个节点。所以这个第一个节点没有前一个节点。

在本声明中

list->prev=allocate();

创建了一个上一个节点，因为它从函数名称开始，它会在列表的开头推送一个新节点。

在本声明中

list->prev->next=list;

表达式list->prev生成新创建节点的地址。此创建的节点应指向列表的当前第一个节点。因此，其数据成员next应包含节点list的地址。

这句话

list->prev->next=list;

这样做。

如果引入中间变量，可以想象更简单。

例如

Element_t *new_node = allocate();

list->prev = new_node;      // list->prev=allocate();
new_node->next = list;     //list->prev->next=list;
list = new_node;           //list=list->prev;

return list;

至于这个问题

这意味着什么：f-＆gt; next-＆gt; prev = f-＆gt; prev？

然后看起来节点f已从列表中删除。现在，它的下一个节点（f->next）将不会指向f，但会指向前一个f节点。

再次，如果引入中间变量将更加明确。

Element_t *previous_node_of_f = f->prev;
Element_t *next_node_of_f = f->next;

next_node_of_f->prev = previous_node_of_f;  // f->next->prev=f->prev

如果要添加这样的声明

previous_node_of_f->next = next_node_of_f;

然后节点f将从列表中完全删除。

       --------------------------------------------------------
       |                                              prev    ^
       |                                                      |
----------------------    ----------------------    ----------------------
| previous_node_of_f |    |         f          |    |    next_node_of_f  |    
----------------------    ----------------------    ----------------------
       |                                                     ^  
       |    next                                             | 
       -------------------------------------------------------

Answer 4

Element_t可能是typedef，类似于以下内容：

typedef struct Element {
    struct Element * next;
    struct Element * prev;
    void * data;
} Element_t;

假设这样，你的链表基本上是这样的：

                  (list)
                     A               B               C
                +----------+    +----------+    +----------+
                | next=B   |--->| next=C   |--->| next=0   |
                | prev=0   |<---| prev=A   |<---| prev=B   |
                | data="A" |    | data="B" |    | data="C" |
                +----------+    +----------+    +----------+

所以现在你想在A

前添加一个新节点N.

                  (list)
     N               A               B               C
+----------+    +----------+    +----------+    +----------+
| next=A   |--->| next=B   |--->| next=C   |--->| next=0   |
| prev=0   |<---| prev=N   |<---| prev=A   |<---| prev=B   |
| data="N" |    | data="A" |    | data="B" |    | data="C" |
+----------+    +----------+    +----------+    +----------+

所以，1。A-＆gt; prev需要设置为N和2. N＆gt; next需要设置为A.

list->prev=allocate();这会分配新的N并且已经分配了A-＆gt; prev = N.

下一行：list->prev->next=list：读取list->prev作为刚分配的新节点。然后它是N＆gt; next = A - 第二步。

您的新元素已在列表中链接。显然，allocate()需要将next和prev初始化为NULL。

这意味着什么：f-＆gt; next-＆gt; prev = f-＆gt; prev？

取决于它的写作地点。在这里，它可能是一个函数的一部分，它从列表中删除一个节点。

理解c中的代码（链表）

4 个答案: