C++ 此函数是否将新节点添加到链表的末尾？_C++_Sorting_Recursion_Insert_Singly Linked List

C++ 此函数是否将新节点添加到链表的末尾？

c++ sorting recursion

C++ 此函数是否将新节点添加到链表的末尾？,c++,sorting,recursion,insert,singly-linked-list,C++,Sorting,Recursion,Insert,Singly Linked List,我想知道，这是否会在列表的末尾插入一个节点？假设我有一个1->2->3->8->NULL的链表，我想插入一个数据为9的新节点。它将递归地遍历到NULL。当head指向NULL时，head=nextNode不工作。或者头部仍然指向8的节点？多谢各位我只想知道这个可以在列表的末尾插入一个节点吗？我不这么认为 void insert(Node *&head, int data) { if (head == NULL || data <head ->data) {

我想知道，这是否会在列表的末尾插入一个节点？假设我有一个1->2->3->8->NULL的链表，我想插入一个数据为9的新节点。它将递归地遍历到NULL。当head指向NULL时，head=nextNode不工作。或者头部仍然指向8的节点？多谢各位

我只想知道这个可以在列表的末尾插入一个节点吗？我不这么认为

void insert(Node *&head, int data) {
    if (head == NULL || data <head ->data) {
        Node *nextNode = new Node;
        nextNode->data = data;
        nextNode->next = head;
        head= nextNode;
    } else {
        insert(head->next, data);
    }
}

void插入（节点*&head，int数据）{
if（head==NULL | |数据）{
Node*nextNode=新节点；
下一个节点->数据=数据；
下一个节点->下一个=头部；
头=下一个节点；
}否则{
插入（头->下一步，数据）；
}
}

它将一个新节点插入到已排序位置的链表中。至少，这是我们的意图

以下是使用输入的已编译代码，该代码演示了以下行为：

感兴趣的行：

if（head==NULL | | datadata）

新条目被置于该条件通过的位置。

此功能完全错误，因为它会导致内存泄漏。它只在第一次迭代中有效。我正在给你写代码，但它不会帮助你学习

if(head==NULL)
{
    Node *nxtNode=new Node;
    nxtNode->data=data;
    head=nxtNode;
    nxtNode->next=NULL;
    return;
}
if(head->next==NULL||data<head->next->data)
{
    Node *nxtNode=new Node;
    nxtNode->data=data;
    nxtNode->next=head->next;
    head->next=nxtNode->next;
    return;
}
else
{
    insert(head->next,data);
}

if（head==NULL）
{
Node*nxtNode=新节点；
nxtNode->data=数据；
head=nxtNode；
nxtNode->next=NULL；
返回；
}
if（head->next==NULL | | datanext->data）
{
Node*nxtNode=新节点；
nxtNode->data=数据；
nxtNode->next=head->next；
head->next=nxtNode->next；
返回；
}
其他的
{
插入（头->下一步，数据）；
}

这种情况

if ( head == NULL || data < head->data )

因为data

的值不小于现有节点的任何数据值

因此，函数将被递归调用，直到下一个节点将等于NULL（也就是说，函数将被调用，引用最后一个节点中下一个等于NULL ptr的数据成员）。因此，新节点将附加到列表的尾部。这是列表中值为NULL的最后一个指针将替换为新节点。因此，节点将按升序插入列表中

这是一个演示程序

#include <iostream>

struct Node
{
    int data;
    Node *next;
};

void insert( Node * &head, int data ) 
{
    if ( head == nullptr || data < head ->data ) 
    {
        head = new Node { data, head };
    } 
    else 
    {
        insert( head->next, data );
    }
}

std::ostream & output( const Node *head, std::ostream &os = std::cout )
{
    for ( ; head != nullptr; head = head->next)
    {
        os << head->data << " -> ";
    }

    return os << "null";
}

int main() 
{
    Node *head = nullptr;

    for ( int data : { 3, 8, 1, 2, 9 } )
    {
        insert( head, data );
        output( head ) << '\n';
    }

    return 0;
}

要清楚地考虑一个包含两个节点的列表，数据“代码< 1”/代码>和<代码> 3 < /代码> .<

head  |node A with value 1|next B|  |node B with value 3| next nullptr|
 |______________|              |______________|

您正在尝试插入一个值为

的节点

该函数是用

insert( head, 2 );

头部->等于1的数据不大于2。所以这个函数被称为like

insert( ( node A )->next, 2 );

（节点A）->下一步->等于3的数据大于2

因此，您必须用值2替换新创建节点的地址（node A）->next

head  |node A with value 1|next C|  |node B with value 3| next nullptr|
 |______________|              |              |
                               |              |
          |node C with value 2 | the value of next B of node A|

您的函数正在生成大量悬空指针，代码不会泄漏内存。类应该有一个析构函数来遍历列表并取消分配它。该函数似乎也工作得很好。@okovko没有这方面的迹象，如果只有在节点周围有列表类包装的情况下，该函数才会遍历析构函数。在节点中这样做就是邀请堆栈overflow@Swift-FridayPie，而且他们使用所谓的Java方法（这是我的术语），在这种方法中，您不能使用例如指针到指针。因此，逻辑分为头节点是否等于NULL或头节点是否不等于NULL。我的代码将完美运行，但现在我知道他正在使用*&这就是他这么做的原因。但每当我这样做时，我都会感到不安。我不明白的是，如果指针指向NULL，下一个节点将指向NULL。然后，NULL指向nextNode？@HageNezz值为8的节点下一个数据成员将具有NULL。此数据成员由新创建的节点替换，并且此已创建节点的下一个数据成员将设置为节点下一个数据成员的上一个值，值8为NULL。因此，附加的节点将是列表的最后一个节点。是的，这可以在列表的末尾插入一个节点。在我的答案中的链接中自己尝试一下。可能函数中令人困惑的部分是参数的名称

head

。除了第一次迭代之外，它不是列表的头。

insert( ( node A )->next, 2 );

head  |node A with value 1|next C|  |node B with value 3| next nullptr|
 |______________|              |              |
                               |              |
          |node C with value 2 | the value of next B of node A|