C++ 将未排序的链接列表转换为已排序的链接列表？（C+；+；）

我在尝试将INSERT函数转换为按字母顺序对节点排序的函数时遇到问题。我已经写下了我到目前为止所做的尝试……但它只检查第一个节点的名称，看它是否大于函数参数中新节点的给定名称。有人能告诉我，我将如何通过每个节点移动，并能够比较它们的键（名称），并相应地将它们放置在左右？下面是我的代码和我的INSERT函数中的内容

  // UnSortedLnkList.h
    //----------------------------

    #include <iostream>
    #include <afxwin.h>

    using namespace std;

    #define new DEBUG_NEW

    struct Node  {
        string m_name;  // key
        int m_age;

        Node* m_next;
        Node(const string& name, int age, Node* next = NULL);
    };

    ostream& operator<< (ostream&, const Node&);

    class ULnkList  {
        friend ostream& operator<< (ostream&, const ULnkList&); // 1.5
    public:
        ULnkList();
        // copy ctor
        ULnkList(const ULnkList& existingList );            // 5
        ~ULnkList();                                        // 4

        bool IsEmpty() const;
        int Size() const;
        bool Insert(const string& name, int age);           // 1
        bool Delete(const string& name);                    // 3
        bool Lookup(const string& name, int& age) const;    // 2

        ULnkList& operator =(const ULnkList& list2);        // 6

        bool Delete2(const string& name);   


    private:

        Node* m_head;   // points to head of the list
        int m_num;     // the number of entries in the list

        // helper functions:
        void Clear();                                       // 7
        void Copy(const ULnkList& list2);                   // 8
    };


    // UnSortedLnkList.cpp
    //----------------------------
    #include "UnSortedLnkList.h"
    #include <iostream>
    #include <string>
    using namespace std;

    Node::Node(const string& name, int age, Node* next)
    : m_name(name), m_age(age), m_next(next)
    {}


    ostream& operator<< (ostream& os, const Node& n)    // cout << n;
    {
        os << "Name: " << n.m_name << "\tAge: " << n.m_age;
        return os;
    }

    ULnkList::ULnkList()
    : m_head(new Node("",-99,NULL)), m_num(0)
    {
        //m_head = new Node("",-99,NULL);
    }
    //
    ULnkList::ULnkList(const ULnkList& existingList ) 
    {
        Copy(existingList);
    }

    void ULnkList::Copy(const ULnkList& existingList)
    {
        m_num = existingList.m_num;
        // create dummy node
        m_head = new Node("",-99,NULL);
        // traverse existing list
        Node *pe = existingList.m_head->m_next;
        Node *pThis = m_head;
        while( pe != 0)
        {
            // create a copy of the Node in OUR list
            pThis->m_next  = new Node(pe->m_name,pe->m_age,0);

            // update pointers
            pe = pe->m_next;
            pThis = pThis->m_next;
        }
    }

    void ULnkList::Clear()
    {
        Node *p = m_head->m_next;
        Node *tp = m_head;          // trail pointer
        while( p != 0)
        {
            delete tp;

            // update pointers
            tp = p;  // 
            p = p->m_next;
        }

        delete tp;
    }

    ULnkList& ULnkList::operator =(const ULnkList& list2)  // list1 = list2;
    {
        // list1 = list1;  // check for self-assignment
        if( this != &list2 )
        {
            this->Clear(); // normally Clear();
            this->Copy(list2);
        }

        // l1 = l2 = l3;

        return *this;
    }

    bool ULnkList::IsEmpty() const
    {
        return m_num == 0;
        // return m_head->m_next == NULL;
    }

    int ULnkList::Size() const
    {

        return m_num;
    }
    //

    ULnkList::Insert(const string& name, int age)
    {
        Node *current = m_head->m_next;
        Node *previous = m_head;
        if (m_head->m_next == NULL) 
        {
            m_head->m_next   = new Node(name,age,m_head->m_next); 
            m_num++;
            return true;
        }
        if (name < m_head->m_next->m_name)
        {
            m_head->m_next = new Node(name,age,m_head->m_next);
            m_num++;
            return true;
        }




        return true;
    }

    //
    ostream& operator<< (ostream& os, const ULnkList& list) // cout << list;
    {
        Node *p = list.m_head->m_next; // first node with data

        while( p != 0 )
        {
            cout << *p << endl;  // ????

            // update p
            p = p->m_next;
        }
        cout << "--------------------------------------" << endl;

        return os;
    }

    //   input: name
    //// output: age if found
    bool ULnkList::Lookup(const string& name, int& age) const
    {
        // linear search
        Node *p = m_head->m_next;

        while( p != 0)
        {
            if( name == p->m_name )
            {
                // found it
                age = p->m_age;
                return true;
            }

            // update p
            p = p->m_next;
        }
        return false;
    }
    //
    bool ULnkList::Delete(const string& name)
    {
        Node *p = m_head->m_next;
        Node *tp = m_head;          // trail pointer
        while( p != 0)
        {
            if( name == p->m_name )
            {
                // found it, so now remove it
                // fix links
                tp->m_next = p->m_next;
                // delete the node
                delete p;

                return true;
            }

            // update pointers
            tp = p;  // tp = tp->m_next;
            p = p->m_next;
        }
        return false;
    }

    bool ULnkList::Delete2(const string& name)
    {
        Node *p = m_head;
        while( p->m_next != 0 )     // ?????
        {
            if( p->m_next->m_name == name )
            {
                Node *save = p->m_next;
                // remove the node
                // fix links
                p->m_next = p->m_next->m_next;
                // delete memory
                delete save;
                return true;
            }

            // update pointers
            p = p->m_next;
        }
        return false;
    }
    //
    ULnkList::~ULnkList()
    {
        Clear();
    }
    //

//UnSortedLnkList.h
//----------------------------
#包括
#包括
使用名称空间std；
#定义新调试\u新
结构节点{
字符串m_name；//键
int m_年龄；
Node*m_next；
节点（常量字符串和名称，整数年龄，节点*下一个=NULL）；
};
ostream&Operator_next；
}
删除tp；
}
ULnkList&ULnkList:：operator=（const-ULnkList&list2）//list1=list2；
{
//list1=list1；//检查自分配
如果（此！=&list2）
{
此->清除（）；//正常清除（）；
此->复制（列表2）；
}
//l1=l2=l3；
归还*这个；
}
bool ULnkList:：IsEmpty（）常量
{
返回m_num==0；
//返回m_head->m_next==NULL；
}
int ULnkList:：Size（）常量
{
返回m_num；
}
//
ULnkList:：Insert（常量字符串和名称，整数）
{
节点*current=m_head->m_next；
节点*previous=m_头；
如果（m_head->m_next==NULL）
{
m_head->m_next=新节点（名称、年龄、m_head->m_next）；
m_num++；
返回true；
}
如果（名称m_下一步->m_名称）
{
m_head->m_next=新节点（名称、年龄、m_head->m_next）；
m_num++；
返回true；
}
返回true；
}
//
ostream&Operator_next；
}
返回false；
}
//
bool ULnkList:：Delete（常量字符串和名称）
{
节点*p=m_头->m_下一步；
Node*tp=m_head；//跟踪指针
while（p！=0）
{
如果（名称==p->m_名称）
{
//找到了，现在把它移除
//固定链接
tp->m_next=p->m_next；
//删除节点
删除p；
返回true；
}
//更新指针
tp=p；//tp=tp->m_next；
p=p->m_下一步；
}
返回false；
}
布尔ULnkList:：Delete2（常量字符串和名称）
{
节点*p=m_头；
而（p->m_next！=0）/？？？？？
{
如果（p->m_next->m_name==name）
{
节点*save=p->m_next；
//删除节点
//固定链接
p->m_next=p->m_next->m_next；
//删除内存
删除保存；
返回true；
}
//更新指针
p=p->m_下一步；
}
返回false；
}
//
ULnkList:：~ULnkList（）
{
清除（）；
}
//

我猜这是家庭作业，所以我不打算写代码。我建议您的Insert（）函数可以通过比较输入字符串，然后执行Insert逻辑，从头到尾遍历列表，直到找到“正确”的位置。这是假设您必须使用文本列表作为数据结构。如果希望平均插入性能更好，可以使用二叉树作为底层结构，但这会使列表遍历更复杂。

您的问题在于以下代码：

    if (name < m_head->m_next->m_name)
    {
        m_head->m_next = new Node(name,age,m_head->m_next);
        m_num++;
        return true;
    }

这将以升序排序的方式插入。

---

我还没有测试过，但请告诉我它是否有效！希望这有帮助

对于这段代码，我有一句忠告

if(name > m_head->m_name ){
while(name > current->m_next->m_name){
    current = current->m_next;
}
// add temp = current->next
current->m_next = new Node(name,age)
// current->next->next = temp

---

您不希望在插入位置后丢失列表。

如果这是家庭作业，请将其标记为家庭作业。否则，不要使用链表生成一个蹩脚的模仿

std:：set

（好吧，我没有仔细看——可能它是一个蹩脚的模仿

std:：multiset

）。哦，既然您没有编写模板，那么也要从代码中删除

this->

。

if(name > m_head->m_name ){
while(name > current->m_next->m_name){
    current = current->m_next;
}
// add temp = current->next
current->m_next = new Node(name,age)
// current->next->next = temp