C++ 将节点插入到无头指针的已排序列表中

有人能改进这个答案吗？我相信AddNode函数可以非常小。将节点插入已排序的链表是一个问题，但有一个警告。你没有头指针。因此，如果节点数据小于头部，则必须将数据交换到类中

class SList
{
public:
    SList(int value = 0,
          SList* n = nullptr) :
        foo(value), pNext(n)
    {
    }

    void Output() 
    { 
        cout << foo;  
        if (nullptr != pNext) 
        {
            cout << ", ";
            pNext->Output(); 
        }
    }  

    void AddNode(int value)
    {
        SList* head = this;

        // Insert to front
        if (value < head->foo)
        {
            int temp = foo;
            foo = value;
            SList* pNode = new SList(temp);
            SList* pNextTmp = this->pNext;
            this->pNext = pNode;
            pNode->pNext = pNextTmp;
            return;
        }

        // Insert to end
        if ((value > head->foo) && nullptr == head->pNext)
        {
            SList* pNode = new SList(value);
            this->pNext = pNode;
            return;
        }

        // Middle case
        while (head)
        {
            if (value > head->foo)
            {
                if (head->pNext)
                {
                    if (value < head->pNext->foo)
                    {
                        SList* pNode = new SList(value);
                        SList* pNodeTemp = head->pNext;
                        head->pNext = pNode;
                        pNode->pNext = pNodeTemp;
                        return;
                    }
                }
                else
                {
                    SList* pNode = new SList(value);
                    head->pNext = pNode;
                }
            }

            head = head->pNext;
        }
    }

protected:
    int         foo;
    SList*      pNext;
};

void sortedListTest()
{
    SList* list = new SList(5);

    cout << endl;
    list->AddNode(19);
    list->AddNode(3);
    list->AddNode(8);
    list->AddNode(12);
    list->AddNode(33);
    list->AddNode(9);
    list->AddNode(1);
    list->AddNode(23);
    list->Output();
    cout << endl;
}

类SList
{
公众：
SList（int值=0，
SList*n=nullptr）：
foo（值），pNext（n）
{
}
无效输出（）
{ 
库特福）
{
int-temp=foo；
foo=价值；
SList*pNode=新SList（温度）；
SList*pNextTmp=this->pNext；
此->pNext=pNode；
pNode->pNext=pNextTmp；
返回；
}
//插入到末端
如果（（value>head->foo）和&nullptr==head->pNext）
{
SList*pNode=新SList（值）；
此->pNext=pNode；
返回；
}
//中间格
while（head）
{
如果（值>头部->foo）
{
如果（头->下一页）
{
如果（值pNext->foo）
{
SList*pNode=新SList（值）；
SList*pNodeTemp=head->pNext；
head->pNext=pNode；
pNode->pNext=pNodeTemp；
返回；
}
}
其他的
{
SList*pNode=新SList（值）；
head->pNext=pNode；
}
}
head=head->pNext；
}
}
受保护的：
int foo；
SList*pNext；
};
无效分类列表测试（）
{
滑动列表*列表=新滑动列表（5）；
cout-AddNode（19）；
列表->添加节点（3）；
列表->添加节点（8）；
列表->添加节点（12）；
列表->添加节点（33）；
列表->添加节点（9）；
列表->添加节点（1）；
列表->添加节点（23）；
列表->输出（）；
cout如果值小于head，则首先测试并创建新的head。
若该值大于head，则迭代直到下一个元素大于head，并在之前插入

class SList
{
public:
    SList(int value = 0,
                 SList* n = nullptr) :
        foo(value), pNext(n)
    {
    }

    void Output() 
    { 
        cout << foo;  
        if (nullptr != pNext) 
        {
            cout << ", ";
            pNext->Output(); 
        }
    }  

    void AddNode(int value)
    {
        SList* head = this;

        // Insert to front
        if (value < head->foo)
        {
            SList* pNode = new SList(foo);
            pNode->pNext = this->pNext;
            this->pNext = pNode;
            foo = value;
            return;
        }

        while ( head->pNext && head->pNext->foo < value )
            head = head->pNext;

        SList* pNode = new SList(value);
        pNode->pNext = head->pNext;
        head->pNext = pNode;
    }

protected:
    int         foo;
    SList*      pNext;
};

void sortedListTest()
{
    SList* list = new SList(5);

    cout << endl;
    list->AddNode(19);
    list->AddNode(3);
    list->AddNode(8);
    list->AddNode(12);
    list->AddNode(33);
    list->AddNode(9);
    list->AddNode(1);
    list->AddNode(23);
    list->Output();
    cout << endl;
}

类SList
{
公众：
SList（int值=0，
SList*n=nullptr）：
foo（值），pNext（n）
{
}
无效输出（）
{ 
库特福）
{
SList*pNode=新SList（foo）；
pNode->pNext=此->pNext；
此->pNext=pNode；
foo=价值；
返回；
}
while（head->pNext&&head->pNext->foopNext；
SList*pNode=新SList（值）；
pNode->pNext=head->pNext；
head->pNext=pNode；
}
受保护的：
int foo；
SList*pNext；
};
无效分类列表测试（）
{
滑动列表*列表=新滑动列表（5）；
cout-AddNode（19）；
列表->添加节点（3）；
列表->添加节点（8）；
列表->添加节点（12）；
列表->添加节点（33）；
列表->添加节点（9）；
列表->添加节点（1）；
列表->添加节点（23）；
列表->输出（）；
cout另一个版本：

基本上是复制元素（之后必须插入）并更新下一个指针和该副本的数据。需要为head处理特殊情况

#include<iostream>
using namespace std;

class SList
{
public:
    SList(int value = 0,
          SList* n = nullptr) :
        foo(value), pNext(n)
    {
    }

    void Output() 
    { 
        cout << foo;  
        if (nullptr != pNext) 
        {
            cout << ", ";
            pNext->Output(); 
        }
    }  

    void AddNode(int value)
    {
        SList* current = this;
        SList* prev = NULL;

        while( current && current->foo < value)
        {
            prev = current;
            current = current->pNext;
        }

        if(prev)
        {
            SList *newNode =  new SList(*prev);
            newNode->foo = value;
            prev->pNext = newNode;
        }
        else
        {
            SList *newNode =  new SList(*current);
            current->foo = value;
            current->pNext = newNode;
        }



    }

protected:
    int         foo;
    SList*      pNext;
};

int main()
{
    SList* list = new SList(5);

    cout << endl;
    list->AddNode(19);
    list->AddNode(3);
    list->AddNode(8);
    list->AddNode(12);
    list->AddNode(33);
    list->AddNode(9);
    list->AddNode(1);
    list->AddNode(23);
    list->Output();
    cout << endl;
}

#包括
使用名称空间std；
班级名单
{
公众：
SList（int值=0，
SList*n=nullptr）：
foo（值），pNext（n）
{
}
无效输出（）
{ 
cout foo<值）
{
prev=当前值；
当前=当前->pNext；
}
如果（上一个）
{
SList*newNode=新SList（*prev）；
newNode->foo=值；
prev->pNext=newNode；
}
其他的
{
SList*newNode=新SList（*当前）；
当前->foo=值；
当前->pNext=newNode；
}
}
受保护的：
int foo；
SList*pNext；
};
int main（）
{
滑动列表*列表=新滑动列表（5）；
cout-AddNode（19）；
列表->添加节点（3）；
列表->添加节点（8）；
列表->添加节点（12）；
列表->添加节点（33）；
列表->添加节点（9）；
列表->添加节点（1）；
列表->添加节点（23）；
列表->输出（）；
当然，如果你不能有一个head指针，你就需要一个pPrev指针。如果你不能改变数据结构，当你执行//insert to front时，返回新插入的元素，这样调用者就可以将指针指向head，否则列表就会在图中被分割。