blocks|key|3907644|text|在处理指针时，您总是希望确保delete任何不再使用的new对象。这样就不会有任何内存泄漏了。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3907645|边缘条件是，例如，当插入元素时，它是否适用于空列表，当项目将作为第一个元素插入时，作为最后一个元素插入时？通常，在实现insert时，我们对典型元素(即现有列表中间的元素)执行逻辑。但它应该适用于所有情况。我提到的情况可以被认为是边缘条件，并且必须考虑到您想要为列表实现的每个操作。|3907646|entityMap^0|E|6|R|3|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

When dealing with pointers, you always want to make sure you <code>delete</code> any <code>new</code> objects that are no longer in use. That's so there aren't any memory leaks.

Edge conditions are, for example, when inserting an element, does it work for an empty list, when the item will be inserted as the first element, as the last element? Normally, when implementing insert we do the logic for a typical element (i.e. one in the middle of an existing list). But it should work for all cases. The cases I mentioned could be considered edge conditions and have to be considered for each an every operation you want to implement for the list.

blocks|key|3907713|text|由于您使用的是“struct”，而不是“class”，因此为每个节点的操作实现一些函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3907714|更新:我提到class是因为，在链表的面向对象版本中，我注释的函数通常是作为对象的方法实现的，但这些操作在过程化编程中也适用。|offset|length|style|CODE|3907715|示例：|3907716|struct+Node+{
++++++++Node+*next;
++++++++Node+*prev;
++++++++T+datum;
++++};

Node+*first;+++//+points+to+first+Node+in+list,+or+0+if+list+is+empty
Node+*last;++++//+points+to+last+Node+in+list,+or+0+if+list+is+empty

void+NodesLink(Node*+A,+Node*+B)
{
++if+((A+!=+NULL)+&&+(B+!=+NULL))
++{
+++++A->next+=+B;
+++++B->prev+=+A;
++}
}+//+void+NodesLink+(...)

void+NodesInsertAfter(Node*+A,+Node*+NewNode)
{
++if+((A+!=+NULL)+&&+(NewNode+!=+NULL))
++{
+++++Node*+B+=+A->next;
+++++NodesLink(A,+NewNode);
+++++NodesLink(NewNode,+B);
++}
}+//+void+NodesLink+(...)|code-block|syntax|javascript|3907717|独立的实用函数将使您的代码更加一致，并且易于调试和修复。|3907718|entityMap^0|0|6|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|X|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Since you are using a ´struct´, instead of a ´class´, implement some functions for operations for each node.

UPDATE:
I mention <code>class</code> because, the functions I comment, are usually implemented as object' methods, in the object-oriented version of a linked-list,
yet these operations apply as well in procedural programming.

Example:

<pre><code>struct Node {
 Node *next;
 Node *prev;
 T datum;
 };

Node *first; // points to first Node in list, or 0 if list is empty
Node *last; // points to last Node in list, or 0 if list is empty

void NodesLink(Node* A, Node* B)
{
 if ((A != NULL) &amp;&amp; (B != NULL))
 {
 A-&gt;next = B;
 B-&gt;prev = A;
 }
} // void NodesLink (...)

void NodesInsertAfter(Node* A, Node* NewNode)
{
 if ((A != NULL) &amp;&amp; (NewNode != NULL))
 {
 Node* B = A-&gt;next;
 NodesLink(A, NewNode);
 NodesLink(NewNode, B);
 }
} // void NodesLink (...)
</code></pre>

That independent utility functions will make your code more consistent, and easy to debug and fix.

blocks|key|3907731|text|一些边缘情况可能是|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3907732|(a)无节点|3907733|(b)只有一个节点|3907734|(c)在头部/尾部添加节点|3907735|(d)避免遍历列表时出现无限循环|3907736|(e)避免内存泄漏和悬空指针|3907737|这些是应该进行的基本检查。|3907738|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Some of the edge cases might be 
 (a) No node 
(b) Only one node 
(c) Adding node at head/tail 
(d) Avoiding infinite loop while traversing list 
(e) Avoiding memory leaks and dangling pointers 

These are the basic checks that ought to be made.

For example, my instructor said something about not having any memory freed, and deleting pointers when doing operations with linked lists. Furthermore, he said that while doing operations on a doubly-linked lists, you should make sure that your edge cases are okay. Can anyone expand on this? I'm not sure I get what he fully means.

For example, this is the sort of linked list we are working on: 

<pre><code> struct Node {
 Node *next;
 Node *prev;
 T datum;
 };

Node *first; // points to first Node in list, or 0 if list is empty
Node *last; // points to last Node in list, or 0 if list is empty
</code></pre>

What should you keep in mind when doing operations on doubly-linked lists?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

例如，我的讲师说过，在使用链表进行操作时，不要释放任何内存，并删除指针。此外，他说，在对双向链表进行操作时，应该确保边缘情况是正确的。有没有人可以对此进行扩展？我不确定我完全明白他的意思。例如，这是我们正在处理的链表类型： struct Node {        Node *next;        Node *pr...

问在双向链表上进行操作时，您应该记住什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在双向链表上进行操作时，您应该记住什么？EN