C++ 如何在程序中使用此单链表结构来提高性能？

嘿，伙计们，我有一个程序可以对字符串集进行运算。我必须实现两组字符串的加法和减法等功能。我需要让它下降到性能if为O（N+M）的点，其中N，M是字符串集。现在，我相信我的表现是O（N*M），因为我对N的每一个元素，我都经历了M的每一个元素。我特别专注于将减法运算转化为适当的表现，好像我可以将其转化为适当的表现，我相信我可以将知识带到我必须实现的其他事情中

例如，“-”操作符假定是这样工作的

将集合1声明为空集合。
将集合2声明为具有{abc}个元素的集合
将集合3声明为具有（bcd}元素的集合

set1=set2-set3

现在假设set1等于{a}，所以基本上，只需从set3中删除任何元素，也就是set2中的元素

对于加法实现（重载的“+”运算符），我还对字符串进行排序（因为我们必须这样做）

顺便说一句，所有的功能现在都可以工作了

所以我想知道是否有人可以

a） 确认当前我正在进行O（N*m）性能测试
b） 给我一些关于如何将性能提高到O（N+M）的想法/实现

注意：我不能向类strSet或节点结构添加任何成员变量或函数

主程序的实现不是很重要，但我将发布我的类定义和成员函数实现的代码：

strest2.h（我的类和结构的实现）

//类来实现字符串集
//实现并集、交集、减法、，
//等，用于一组字符串
//V1.1 2011年2月15日添加了guard（#ifndef），使用名称空间RCH删除
#ifndef_STRSET_
#定义_STRSET_
#包括
#包括
#包括
//删除：使用名称空间std；2011年2月15日
结构节点{
std：：字符串s1；
节点*下一步；
};
类strSet{
私人：
节点*第一；
公众：
strSet（）；//创建空集
strSet（std:：string s）；//创建单例集
strSet（const strSet©）；//复制构造函数
~strSet（）；//析构函数
int SIZE（）常量；
bool-isMember（std:：string s）const；
strSet运算符+（常量strSet&rtSide）；//并集
strSet运算符-（const strSet&rtSide）；//集减法
strSet&operator=（const strSet&rtSide）；//赋值
};  // strSet课程结束
#endif/\u STRSET_

strest2.cpp（成员功能的实现）

#包括
#包括
#包括
#包括“strest2.h”
使用名称空间std；
strSet:：strSet（）{
第一个=空；
}
strSet:：strSet（字符串s）{
节点*温度；
temp=新节点；
温度->s1=s；
temp->next=NULL；
第一个=温度；
}
strSet：：strSet（const strSet和copy）{
如果（copy.first==NULL）{
第一个=空；
}
否则{
node*n=copy.first；
node*prev=NULL；
while（n）{
node*newNode=新节点；
新建节点->s1=n->s1；
newNode->next=NULL；
如果（上一个）{
prev->next=newNode；
}
否则{
第一个=新节点；
}
prev=newNode；
n=n->next；
}
}
}
strSet:：~strSet（）{
如果（第一个！=NULL）{
while（第一个->下一个！=NULL）{
节点*nextNode=first->next；
第一个->下一个=下一个节点->下一个；
删除下一个节点；
}
}
}
int strSet:：SIZE（）常量{
int size=0；
节点*温度=第一；
while（temp！=NULL）{
大小++；
温度=温度->下一步；
}
返回大小；
}    
bool strSet:：isMember（字符串s）const{
节点*温度=第一；
while（temp！=NULL）{
如果（温度->s1==s）{
返回true；
}
温度=温度->下一步；
}
返回false；
}
strSet strSet:：operator+（常量strSet&rtSide）{
strSet新闻集；
新闻集=*此；
节点*temp=rtSide.first；
while（temp！=NULL）{
字符串newEle=temp->s1；
如果（！isMember（newEle））{
if（newSet.first==NULL）{
节点*新节点；
newNode=新节点；
newNode->s1=newEle；
newNode->next=NULL；
newSet.first=newNode；
}
else if（newSet.SIZE（）==1）{
if（newEles1）{
node*tempNext=newSet.first；
节点*新节点；
newNode=新节点；
newNode->s1=newEle；
newNode->next=tempNext；
newSet.first=newNode；
}
否则{
节点*新节点；
newNode=新节点；
newNode->s1=newEle；
newNode->next=NULL；
newSet.first->next=newNode；
}
}
否则{
node*prev=NULL；
node*curr=newSet.first；
while（curr！=NULL）{
如果（新建s1）{
if（prev==NULL）{
节点*新节点；
newNode=新节点；
newNode->s1=newEle；
新建节点->下一步=当前；
newSet.first=newNode；
打破
}
否则{
节点*新节点；
newNode=新节点；
newNode->s1=newEle；
新建节点->下一步=当前；
prev->next=newNode；
打破
}
}
// Class to implement sets of strings

// Implements operators for union, intersection, subtraction,
//  etc. for sets of strings

// V1.1 15 Feb 2011 Added guard (#ifndef), deleted using namespace RCH

#ifndef _STRSET_
#define _STRSET_

#include <iostream>
#include <vector>
#include <string>
// Deleted: using namespace std;  15 Feb 2011 RCH

struct node {
    std::string s1;
    node * next;
};

class strSet {

private:
    node * first;

public:
    strSet ();  // Create empty set
    strSet (std::string s); // Create singleton set
    strSet (const strSet &copy); // Copy constructor
    ~strSet (); // Destructor

    int SIZE() const;

    bool isMember (std::string s) const;

    strSet  operator +  (const strSet& rtSide);  // Union
    strSet  operator -  (const strSet& rtSide);  // Set subtraction
    strSet& operator =  (const strSet& rtSide);  // Assignment


};  // End of strSet class

#endif  // _STRSET_

#include <iostream>
#include <vector>
#include <string>
#include "strset2.h"

using namespace std;

strSet::strSet() {
    first = NULL;
}

strSet::strSet(string s) {
    node *temp;
    temp = new node;
    temp->s1 = s;
    temp->next = NULL;
    first = temp;
}

strSet::strSet(const strSet& copy) {
    if(copy.first == NULL) {
        first = NULL;
    }
    else {
        node *n = copy.first;
        node *prev = NULL;
        while (n) {
            node *newNode = new node;
            newNode->s1 = n->s1;
            newNode->next = NULL;
            if (prev) {
                prev->next = newNode;
            }
            else {
                first = newNode;
            }
            prev = newNode;
            n = n->next;
        }
    }
}

strSet::~strSet() {
    if(first != NULL) {
        while(first->next != NULL) {
            node *nextNode = first->next;
            first->next = nextNode->next;
            delete nextNode;
        }
    }
}

int strSet::SIZE() const {
    int size = 0;
    node *temp = first;
    while(temp!=NULL) {
        size++;
        temp=temp->next;
    }
    return size;
}    

bool strSet::isMember(string s) const {
    node *temp = first;
    while(temp != NULL) {
        if(temp->s1 == s) {
            return true;
        }
        temp = temp->next;
    }
    return false;
}

strSet strSet::operator +  (const strSet& rtSide) {
    strSet newSet;
    newSet = *this;
    node *temp = rtSide.first;
    while(temp != NULL) {
        string newEle = temp->s1;
        if(!isMember(newEle)) {
            if(newSet.first==NULL) {
                node *newNode;
                newNode = new node;
                newNode->s1 = newEle;
                newNode->next = NULL;
                newSet.first = newNode;
            }
            else if(newSet.SIZE() == 1) {
                if(newEle < newSet.first->s1) {
                    node *tempNext = newSet.first;
                    node *newNode;
                    newNode = new node;
                    newNode->s1 = newEle;
                    newNode->next = tempNext;
                    newSet.first = newNode;
                }
                else {
                    node *newNode;
                    newNode = new node;
                    newNode->s1 = newEle;
                    newNode->next = NULL;
                    newSet.first->next = newNode;
                }
            }
            else {
                node *prev = NULL;
                node *curr = newSet.first;
                while(curr != NULL) {
                    if(newEle < curr->s1) {
                        if(prev == NULL) {
                            node *newNode;
                            newNode = new node;
                            newNode->s1 = newEle;
                            newNode->next = curr;
                            newSet.first = newNode;
                            break;
                        }
                        else {
                            node *newNode;
                            newNode = new node;
                            newNode->s1 = newEle;
                            newNode->next = curr;
                            prev->next = newNode;
                            break;
                        }
                    }
                    if(curr->next == NULL) {
                        node *newNode;
                        newNode = new node;
                        newNode->s1 = newEle;
                        newNode->next = NULL;
                        curr->next = newNode;
                        break;
                    }
                    prev = curr;
                    curr = curr->next;
                }
            }
        }
        temp = temp->next;
    }
    return newSet;
}

strSet strSet::operator - (const strSet& rtSide) {
    strSet newSet;
    newSet = *this;
    node *temp = rtSide.first;
    while(temp != NULL) {
        string element = temp->s1;
        node *prev = NULL;
        node *curr = newSet.first;
        while(curr != NULL) {
            if( element < curr->s1 ) break;
            if( curr->s1 == element ) {
                if( prev == NULL) {
                    node *duplicate = curr;
                    newSet.first = newSet.first->next;
                    delete duplicate;
                    break;
                }
                else {
                    node *duplicate = curr;
                    prev->next = curr->next;
                    delete duplicate;
                    break;
                }
            }
            prev = curr;
            curr = curr->next;
        }
        temp = temp->next;
    }
    return newSet;
}

strSet& strSet::operator =  (const strSet& rtSide) {
    if(this != &rtSide) {
        if(first != NULL) {
            while(first->next != NULL) {
                node *nextNode = first->next;
                first->next = nextNode->next;
                delete nextNode;
            }
        }
        if(rtSide.first == NULL) {
            first = NULL;
        }
        else {
            node *n = rtSide.first;
            node *prev = NULL;
            while (n) {
                node *newNode = new node;
                newNode->s1 = n->s1;
                newNode->next = NULL;
                if (prev) {
                    prev->next = newNode;
                }
                else {
                    first = newNode;
                }
                prev = newNode;
                n = n->next;
            }
        }
    }
    return *this;
}