集合的模拟实现

最新推荐文章于 2023-09-10 20:28:56 发布

aikozhang1988

最新推荐文章于 2023-09-10 20:28:56 发布

阅读量595

点赞数

原文链接：http://www.cnblogs.com/laixiaolian/p/5676588.html

版权

1、题目（函数模板）

我们可以用一个数组来模拟集合，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用模板函数实现集合元素的增加、删除和查找功能。

三个模板函数如下：

int addSet(T * myset, T elem，int len)

int deleSet(T * myset, T elem, int len)

int findElem(T * myset, T elem, int len)

其中，addSet向集合中添加一个元素，deleSet从集合中删除一个元素，findElem判断elem是否是集合成员,三个函数分别返回元素插入位置，删除位置和存在位置。

主函数有如下数据成员：

int intSet[100]

double douSet[100]

String StrSet[100] 分别是int类型、double类型、String的数组集合。

int intLen, douLen, strLen分别是int类型、double类型、String的数组集合的长度

完成上述函数模板和主函数，主函数根据输入的信息，建立初始的空集合，调用三个模板函数分别对intSet、douSet和StrSet执行相应的操作，并输出对应的集合信息。

输入格式：

每一行为一个集合操作，每行的第一个数字为集合元素类型，1为整型元素，2为浮点型元素，3为String类型，第二个数字为集合操作类型，1为插入，2为删除，3为查找，第三个为集合元素，集合元素类型视第一个数字给定的集合元素类型而定。输入0时标志输入结束。

输出格式：

输出当前操作的执行位置（插入位置、删除位置和存在位置）

删除操作时，如果元素X不存在，输出“X is not exist!”。

插入操作时，如果集合已满，输出“Full Set.”若元素已存在，输出“X is already exist!”

查找操作时，如果找不到元素，输出“X is not exist!”。

输入：

1 1 1

1 1 2

1 3 1

1 2 1

1 2 3

1 3 1

2 1 1.1

2 1 2.2

2 1 3.3

2 3 1.1

2 2 2.2

3 1 abc

3 1 bcd

3 3 abc

3 2 abc

3 3 abc

输出：

3 is not exist!

1 is not exist!

2.2 is not exist!

abc is not exist!

2、代码（函数模板）

#include<iostream>
#include<string>
using namespace std;
template <class T>
int addSet(T *myset, T elem,int len)
{
    bool flag=false;
    for(int i=0; i<=len; i++)
    {
        if(elem==myset[i]&&len!=i)
        {
            flag=true;
            break;
        }
    }
    if(flag==true)
    {
        cout<<elem<<" is already exist!"<<endl;
    }
    else if(flag==false)
    {
        myset[len]=elem;
        cout<<len<<endl;
        len++;
    }
    return len;
}

template <class T>
int deleSet(T * myset, T elem, int len)
{
    bool flag=false;
    int i=0;
    for(i=0; i<len; i++)
    {
        if(myset[i]==elem)
        {
            flag=true;

            break;
        }
    }
    if(flag==true)
    {
        cout<<i<<endl;
        for(int j=i; j<len-1&&len>1; j++)
        {
            myset[j]=myset[j+1];
        }

    }
    else
    {
        cout<<elem<<" is not exist!"<<endl;
    }

    return i;
}

template <class T>
int findElem(T * myset, T elem, int len)
{
    int i=0;
    bool flag=false;
    for(i=0; i<len; i++)
    {
        if(myset[i]==elem)
        {
            flag=true;
            cout<<i<<endl;
            break;
        }
    }
    if(flag==false)
    {
        cout<<elem<<" is not exist!"<<endl;
    }
    return i;
}

int main()
{
    int intSet[100] ;

    double douSet[100];

    string StrSet[100] ;
    int temp,ch;
    int intLen=0, douLen=0, strLen=0;
    while(cin>>ch)
    {
        if(ch==0)
        {
            break;
        }
        if(ch==1)
        {
            cin>>temp>>intSet[intLen];
            if(temp==1)
            {
            intLen=addSet(intSet,intSet[intLen],intLen);
                
            }
            if(temp==2)
            {
                deleSet(intSet, intSet[intLen], intLen);
                intLen--;
                if(intLen<0)
                {
                    intLen=0;
                }
            }
            if(temp==3)
            {
                findElem(intSet, intSet[intLen], intLen);
            }

        }
        if(ch==2)
        {
            cin>>temp>>douSet[douLen];
            if(temp==1)
            {
                douLen=addSet(douSet, douSet[douLen], douLen);
            }
            if(temp==2)
            {
                deleSet(douSet, douSet[douLen], douLen);
                douLen--;
                if(douLen<0)
                {
                    douLen=0;
                }
            }
            if(temp==3)
            {
                findElem(douSet, douSet[douLen], douLen);
            }

        }
        if(ch==3)
        {
            cin>>temp>>StrSet[strLen];
            if(temp==1)
            {
                strLen=addSet(StrSet,StrSet[strLen],strLen);
            }
            if(temp==2)
            {
                deleSet(StrSet,StrSet[strLen],strLen);
                strLen--;
                if(strLen<0)
                {
                    strLen=0;
                }
            }
            if(temp==3)
            {
                findElem(StrSet,StrSet[strLen],strLen);
            }

        }
    }
    return 0;
}

3、题目（类模板）

我们可以用一个类来模拟集合及集合运算，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用类模板实现集合及集合运算，包括集合元素的增加、删除和查找的等基本功能。

集合模板类MySet包括数据如下：

T data[100];//用数组来存放所有的集合元素，最多不超过100个元素

int count;//表示目前集合中有多少个元素

包括成员函数如下：

构造函数若干个，集合运算函数如下：

int addSet( T elem)

int deleSet(T elem)

int findElem(T elem)

主函数有如下数据成员：

MySet<\int> intSet;（反斜杠是转义字符，使用时去掉）

MySet<\double> douSet;

MySet<\string> strSet;

分别是int类型、double类型、String的集合。

完成上述类模板和主函数，主函数根据输入的信息，建立初始的三种不同类型的空集合对象，调用成员函数分别对intSet、douSet和StrSet执行相应的操作，并输出对应的集合信息。

输入格式：

输出格式：

输出当前操作的执行位置（插入位置、删除位置和存在位置）

删除操作时，如果元素X不存在，输出“X is not exist!”。

插入操作时，如果集合已满，输出“Full Set.”若元素已存在，输出“X is already exist!”

查找操作时，如果找不到元素，输出“X is not exist!”。

输入：

1 1 1

1 1 2

1 3 1

1 2 1

1 2 3

1 3 1

2 1 1.1

2 1 2.2

2 1 3.3

2 3 1.1

2 2 2.2

3 1 abc

3 1 bcd

3 3 abc

3 2 abc

3 3 abc

输出：

3 is not exist!

1 is not exist!

2.2 is not exist!

abc is not exist!

4、代码（类模板）

#include<iostream>
#include<string>
using namespace std;
template <class T>
class MySet
{
    private:
        T data[100];
        int count;
    public:
        void set(T a,int len)
        {
            data[len]=a;
            count=len;
        }
        void de(int l)
        {
            count=l;
        }
        int addSet( T elem);

        int deleSet(T elem);

        int findElem(T elem);
};

template <class T>
int MySet<T>::addSet(T elem)
{

    bool flag=false;
    if(count>99)
    {
        cout<<"Full Set."<<endl;
    }
    else
    {
        for(int i=0; i<=count; i++)
        {
            if(elem==data[i]&&count!=i)
            {
                flag=true;
                break;
            }
        }
        if(flag==true)
        {
            cout<<elem<<" is already exist!"<<endl;
        }
        else if(flag==false)
        {
            data[count]=elem;
            cout<<count<<endl;
            count++;
        }
    }
    return count;
}

template <class T>
int MySet<T>::deleSet(T elem)
{
    bool flag=false;
    int i=0;
    for(i=0; i<count; i++)
    {
        if(data[i]==elem)
        {
            flag=true;
            break;
        }
    }
    if(flag==true)
    {
        cout<<i<<endl;
        for(int j=i; j<count-1&&count>1; j++)
        {
            data[j]=data[j+1];
        }
    }
    else
    {
        cout<<elem<<" is not exist!"<<endl;
    }
    return i;
}

template<class T>
int MySet<T>::findElem(T elem)
{
    int i=0;
    bool flag=false;
    for(i=0; i<count; i++)
    {
        if(data[i]==elem)
        {
            flag=true;
            cout<<i<<endl;
            break;
        }
    }
    if(flag==false)
    {
        cout<<elem<<" is not exist!"<<endl;
    }
    return i;
}

int main()
{
    MySet<int> intSet;

    MySet<double> douSet;

    MySet<string> strSet;
    int ints;
    double dou;
    string str;
    int ch,temp;
    int i=0,j=0,t=0;
    while(cin>>ch)
    {
        if(ch==0)
        {
            break;
        }
        
        if(ch==1)
        {
            cin>>temp>>ints;
            
            if(temp==1)
            {
                intSet.set(ints,i);
                i=intSet.addSet(ints);
            }
            
            if(temp==2)
            {
                intSet.de(i);
                intSet.deleSet(ints);
                i--;
                if(i<0)
                {
                    i=0;
                }
            }
            
            if(temp==3)
            {
                intSet.de(i);
                intSet.findElem(ints);
            }
        }
        
        if(ch==2)
        {
            cin>>temp>>dou;
            
            if(temp==1)
            {
                douSet.set(dou,j);
                j=douSet.addSet(dou);
            }
            
            if(temp==2)
            {
                douSet.de(j);
                douSet.deleSet(dou);
                j--;
                if(j<0)
                {
                    j=0;
                }
            }
            
            if(temp==3)
            {
                douSet.de(j);
                douSet.findElem(dou);
            }
        }
        
        if(ch==3)
        {
            cin>>temp>>str;
            
            if(temp==1)
            {
                strSet.set(str,t);
                t=strSet.addSet(str);
            }
            
            if(temp==2)
            {
                strSet.de(t);
                strSet.deleSet(str);
                t--;
                if(t<0)
                {
                    t=0;
                }
            }
            
            if(temp==3)
            {
                strSet.de(t);
                strSet.findElem(str);
            }
            
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/laixiaolian/p/5676588.html

aikozhang1988

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
集合的模拟实现

1、题目（函数模板）我们可以用一个数组来模拟集合，add运算用以实现集合元素的增加，delete运算用于实现集合元素的删除，find运算用以实现集合元素的查找，但是目前集合元素类型未知，可以是int、char、double等基本数据类型，也可以是String、Time、Student等对象类型，要求采用模板函数实现集合元素的增加、删除和查找功能。三个模板函数如下：int addSe...
复制链接

扫一扫