C ++链表

Question

I'm working on an assignment using a modified version of the list class.

class List
{
private:
    class Node
    {
    public:
        std::string _entry;
        Node * _link;

        Node(std::string entry, Node * link) : _entry(entry), _link(link)
        {}
    };
};

The objective I am trying to accomplish is after entering a list, I need to be able to delete one member so if i enter:

a
b
c
d
e

I need to be able to delete c, and leave the rest unaffected. My function is:

    bool deleteOneOf(const std::string & target)
        {
            Node * & del = _first;
            Node *  temp = _first;
            if (contains(target))
            { 
               del = find(temp, target);
               del = del->_link;
            }
                delete temp;
                return true;

            }
            else
            {
                return false;
            }

        }

and the find function is:

Node * & find(Node * & ptr, const std::string & target)
    {
        if (ptr == nullptr || ptr->_entry == target)
        {
            return ptr;
        }
        else
        {
            return find(ptr->_link, target);
        }
    }

The problem I'm having is If i input C to be deleted, it doesn't correctly link B to D, so C, D, E, are all deleted rather than just C. So the output is AB, rather than ABDE as it should be.

Answer 1

The code in deleteOneOf() looks slightly confusing to me. It's not clear to me what approach you were trying to implement, but it does not have to be this complicated.

I'm assuming that _first is the head pointer to the list. In that case:

bool deleteOneOf(const std::string & target)
{
    Node **del = &_first;

    while (*del)
    {
         if ((*del)->_entry == target)
         {
             Node *ptr=*del;

             (*del)=ptr->_link;
             delete ptr;
             return true;
         }

         del=&(*del)->_link;
     }
     return false;
}

Unless I'm missing some part of your requirement, this should be all that's needed.