2 顺序表ADT模板简单应用算法设计：删除顺序表中的冗余元素

最新推荐文章于 2022-08-18 12:21:10 发布

GreenBeryl

最新推荐文章于 2022-08-18 12:21:10 发布

阅读量606

点赞数 1

分类专栏：类模版 c++ 文章标签：数据结构

本文链接：https://blog.csdn.net/GreenBeryl/article/details/115587631

版权

c++ 同时被 2 个专栏收录

7 篇文章 0 订阅

订阅专栏

类模版

3 篇文章 0 订阅

订阅专栏

2 顺序表ADT模板简单应用算法设计：删除顺序表中的冗余元素
作者: 冯向阳时间限制: 1S. 章节: DS:线性表

问题描述 :

目的：使用自行设计的顺序表ADT或STL中的vector模板，设计并实现顺序表应用场合的一些简单算法设计。

应用3：试设计一个算法，删除非空顺序表L中的冗余元素，即使得操作之后的顺序表中只保留操作之前表中所有值都不相同的元素（提纯）。

参考函数原型：
（1）顺序表ADT版本
template
void Purge_Sq( Sqlist &L )；

（2）vector版本
template
void Purge_Sq( vector &L )；

输入说明 :

第一行：顺序表的数据元素类型标记（0：int；1：double；2：char；3：string；其余值：输出err）
第二行：待处理顺序表的数据元素（数据元素之间以空格分隔）

输出说明 :

第一行：提纯前顺序表的遍历结果（数据元素之间以“,”分隔）
空行
第二行：提纯后顺序表的遍历结果（数据元素之间以“,”分隔）

输入范例 :
0
13 5 13 9 32 51 76 5 9 8

输出范例 :
13,5,13,9,32,51,76,5,9,8

13,5,9,32,51,76,8

注意⚠️！！！
输入数据最后可能没有换行！！！

vector 版本AC代码：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<vector>
#include<cmath>
using namespace std;

template<class ElemType>
void Cin_int(vector<ElemType> &x)
{
    string s;
    getline(cin,s);
    int num = 0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            x.push_back(num);
            num = 0;
        }
        else
        {
            num = num * 10 + s[i]-'0';
        }
    }
    x.push_back(num);
}
template<class ElemType>
void Cin_double(vector<ElemType> &x)
{
    string s;
    getline(cin,s);
    bool flag = false;
    int t=0;
    double num = 0.0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            num = num / pow(10,t);
            x.push_back(num);
            t=0;
            flag = false;
            num = 0;
        }
        else if(s[i] == '.')
        {
            flag = true;
        }
        else
        {
            if(flag)
                t++;
            num = num * 10 + s[i] - '0';
        }
    }
    num = num / pow(10,t);
    x.push_back(num);
}
template<class ElemType>
void Cin_char(vector<ElemType> &x)
{
    string s;
    getline(cin,s);
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
            continue;
        else
            x.push_back(s[i]);
    }
}
template<class ElemType>
void Cin_string(vector<ElemType> &x)
{
    string s,t;
    getline(cin,s);
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            x.push_back(t);
            t.clear();
        }
        else
        {
            t+=s[i];
        }
    }
    x.push_back(t);
}

template<class ElemType>
void Cout_v(vector<ElemType> x)
{
    cout<<x[0];
    for(int i=1;i<x.size();i++)
    {
        cout<<","<<x[i];
    }
    cout<<endl;
}
template<class ElemType>
void Delect_v(vector<ElemType> &x)
{
    for(int i=0;i<x.size();i++)
    {
        for(int j=i+1;j<x.size();j++)
        {
            if(x[i] == x[j])
            {
                x.erase(x.begin()+j,x.begin()+j+1);
                j--;
            }
        }
    }
}
int main()
{
    int x;
    cin>>x;
    getchar();
    switch(x)
    {
        case 0:
        {
            vector<int> a;
            Cin_int(a);
            Cout_v(a);
            cout<<endl;
            Delect_v(a);
            Cout_v(a);
            break;
        }
        case 1:
        {
            vector<double> b;
            Cin_double(b);
            Cout_v(b);
            cout<<endl;
            Delect_v(b);
            Cout_v(b);
            break;
        }
        case 2:
        {
            vector<char> c;
            Cin_char(c);
            Cout_v(c);
            cout<<endl;
            Delect_v(c);
            Cout_v(c);
            break;
        }
        case 3:
        {
            vector<string> d;
            Cin_string(d);
            Cout_v(d);
            cout<<endl;
            Delect_v(d);
            Cout_v(d);
            break;
        }
        default:
            cout<<"err"<<endl;
    }
    return 0;
}

SqList 顺序表版本 AC代码：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status; //Status 是函数返回值类型，其值是函数结果状态代码。
const int MAXSIZE=100; //顺序表可能达到的最⼤⻓度
template<class ElemType>
class SqList
{
private:
    ElemType *elem; // 存储空间基址
    int length; // 当前⻓度
public:
    //初始化顺序表
    SqList();
    SqList(ElemType a[],int n);
    //析构顺序表
    ~SqList();
    //将顺序表置为空表
    void ListClear( )
    {
        length = 0;
    }
    void ListTraverse();
    //返回顺序表的⻓度
    int GetLength()
    {
        return length;
    }
    //⽤e返回顺序表的第i个元素
    Status GetElem(int i, ElemType &e);
    //删除顺序表的第pos个位置的元素
    Status ListDelete(int i, ElemType &e);
    Status ListInsert_push(ElemType e);
};
template<class ElemType>
Status SqList<ElemType>::ListInsert_push(ElemType e)
{
    if (length == MAXSIZE)
        return ERROR; //当前存储空间已满
    if(length == 0)
        elem[0] = e;
    else
        elem[length] = e; // 插⼊e
    ++ length; // 表⻓增1
    return OK;
} // ListInsert_push
template<class ElemType>
SqList<ElemType>::SqList()
{
    //构造⼀个空的顺序表L
    elem = new ElemType[MAXSIZE]; //为顺序表分配⼀个⼤⼩为MAXSIZE的数组空间
    length = 0; //空表⻓度为0
}
template<class ElemType>
SqList<ElemType>::SqList(ElemType a[],int n)
{
    // 本算法⽣成顺序表
    elem = new ElemType[MAXSIZE]; //为顺序表分配⼀个⼤⼩为MAXSIZE的数组空间
    for(int i = 0; i < n; i++)
    {
        elem[i]=a[i];
    }
    length=n;
}
template<class ElemType>
SqList<ElemType>::~SqList()
{
    //销毁顺序表
    //需要为SqList类实现拷⻉构造函数和重载等于号，才可以在析构函数中delete顺序表，否则程序可能崩溃，因
    //此这⾥暂时将delete语句注释掉了
    //delete elem;
    //length = 0;
}
template<class ElemType>
void Purge_Sq( SqList<ElemType> &l )
{
    for(int i=0;i<l.GetLength()-1;i++)
    {
        ElemType e1,e2;
        l.GetElem(i+1,e1);
        for(int j=i+1;j<l.GetLength();j++)
        {
            l.GetElem(j+1,e2);
            if(e1 == e2)
            {
                ElemType x;
                l.ListDelete(j+1,x);
                j--;
            }
        }
    }
}
template<class ElemType>
Status SqList<ElemType>::GetElem(int i, ElemType &e)
{
    if( i < 1 || i > length ) return ERROR; // 位置不合法
    //⽤e返回线性表L的第i个元素
    e=elem[i - 1];
    return OK;
}
template<class ElemType>
Status SqList<ElemType>::ListDelete(int i, ElemType &e)
{
    // 若1≤i ≤Length+1 ，则以e带回从顺序表L中删除的
    // 第i个元素且返回OK，否则返回ERROR。
    if( i < 1 || i > length ) return ERROR; // 删除位置不合法
    e = elem[i-1];
    for( int j = i; j <= length; ++j)
        elem[j-1] = elem[j]; // 被删除元素之后的元素左移
    -- length; // 表⻓减1
    return OK;
} // ListDelete

template<class ElemType>
void SqList<ElemType>::ListTraverse()
{
    //打印顺序表
    for(int i = 0; i < length-1; i++)
    {
        cout<<elem[i]<<",";
    }
    cout<<elem[length-1]<<endl;
}template<class ElemType>
void Cin_int(SqList<ElemType> &x)
{
    string s;
    getline(cin,s);
    int num = 0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            x.ListInsert_push(num);
            num = 0;
        }
        else
        {
            num = num * 10 + s[i]-'0';
        }
    }
    x.ListInsert_push(num);
}
template<class ElemType>
void Cin_double(SqList<ElemType> &x)
{
    string s;
    getline(cin,s);
    bool flag = false;
    int t=0;
    double num = 0.0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            num = num / pow(10,t);
            x.ListInsert_push(num);
            t=0;
            flag = false;
            num = 0;
        }
        else if(s[i] == '.')
        {
            flag = true;
        }
        else
        {
            if(flag)
                t++;
            num = num * 10 + s[i] - '0';
        }
    }
    num = num / pow(10,t);
    x.ListInsert_push(num);
}
template<class ElemType>
void Cin_char(SqList<ElemType> &x)
{
    string s;
    getline(cin,s);
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
            continue;
        else
            x.ListInsert_push(s[i]);
    }
}
template<class ElemType>
void Cin_string(SqList<ElemType> &x)
{
    string s,t;
    getline(cin,s);
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            x.ListInsert_push(t);
            t.clear();
        }
        else
        {
            t+=s[i];
        }
    }
    x.ListInsert_push(t);
}

int main()
{
    int x;
    cin>>x;
    getchar();
    switch(x)
    {
        case 0:
        {
            SqList<int> z0;
            Cin_int(z0);
            z0.ListTraverse();
            cout<<endl;
            Purge_Sq( z0 );
            z0.ListTraverse();
            break;
        }
        case 1:
        {
            SqList<double> z1;
            Cin_double(z1);
            z1.ListTraverse();
            cout<<endl;
            Purge_Sq( z1 );
            z1.ListTraverse();
            break;
        }
        case 2:
        {
            SqList<char> z2;
            Cin_char(z2);
            z2.ListTraverse();
            cout<<endl;
            Purge_Sq( z2 );
            z2.ListTraverse();
            break;
        }
        case 3:
        {
            SqList<string> z3;
            Cin_string(z3);
            z3.ListTraverse();
            cout<<endl;
            Purge_Sq( z3 );
            z3.ListTraverse();
            break;
        }
        default:
            cout<<"err"<<endl;
    }
    return 0;
}