【东华大学oj】顺序表ADT模板简单应用算法设计：有序顺序表的合并

顺序表ADT模板简单应用算法设计：有序顺序表的合并

时间限制: 1s

类别: DS：线性表->顺序表--简单

问题描述

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

应用6：假设以两个元素依值递增有序排列的线性表A和B分别表示两个集合，现要求设计一个算法，另辟空间构成一个线性表C，其元素为A和B中元素的交集，且C中的元素也依值递增有序排列，且互不相同。

参考函数原型：

（1）顺序表ADT版本

template<class ElemType>

void Intersect_Sq_OL_C( const SqList<ElemType> &A, const SqList<ElemType> &B, SqList<ElemType> &C )；

（2）vector版本

template<class ElemType>

void Intersect_Sq_OL_C( const vector<ElemType> &A, const vector<ElemType> &B, vector<ElemType> &C )；

输入说明

第一行：顺序表的数据元素类型标记（0：int；1：double；2：char；3：string；其余值：输出err）

第二行：有序顺序表A的数据元素（数据元素之间以空格分隔）

第三行：有序顺序表B的数据元素（数据元素之间以空格分隔）

输出说明

第一行：顺序表A的遍历结果（数据元素之间以“,”分隔）

第二行：顺序表B的遍历结果（数据元素之间以“,”分隔）

空行

第三行：顺序表C的遍历结果（数据元素之间以“,”分隔）

#include <iostream>
#include <vector>
#include <sstream>
#include <limits>
#include <algorithm>
using namespace std;

template<class ElemType>
void Intersect_Sq_OL_C(const vector<ElemType> &A, const vector<ElemType> &B, vector<ElemType> &C )
{
    int j=0;
    for(size_t i=0; i<A.size();)
    {
        while(j < B.size() && A[i] > B[j]) ++j;
        if(j == B.size()) break;
        if(A[i] == B[j])
        {
            if (C.empty() || C.back() != A[i]) { // 避免重复元素
                C.push_back(A[i]);
            }
            ++i;
            ++j;
        }
        else {
            ++i;
        }
    }
}

template<typename T>
void printVector(const vector<T>& v)
{
    for(size_t i = 0; i < v.size(); ++i)
    {
        cout << (i > 0 ? "," : "") << v[i];
    }
    cout << endl;
}

int main()
{
    int type;
    cin>>type;
    cin.ignore(numeric_limits<streamsize>::max(), '\n'); // 忽略换行符
    string line;
    getline(cin, line);  // 读取一行作为顺序表的数据
    stringstream ss(line);// 将一行数据放入字符串流中


    switch(type)
    {
    case 0:
    {
        vector<int> via,vib,vic;
        int tia,tib;
        // 读取A的内容
        while (ss >> tia) via.push_back(tia);
        cin.clear(); // 清除cin的错误状态

        // 重新读取一行作为顺序表B的数据
        getline(cin, line);
        stringstream ssbi(line); // 创建一个新的stringstream对象专门用于B
        while (ssbi >> tib) vib.push_back(tib);// 确保将变量t添加到vib中

        printVector(via);
        printVector(vib);
        cout<<endl;
        Intersect_Sq_OL_C(via,vib,vic);
        printVector(vic);
        break;
    }
    case 1:
    {
        vector<double> vda,vdb,vdc;
        double tda,tdb;
        // 读取A的内容
        while (ss >> tda) vda.push_back(tda);
        cin.clear(); // 清除cin的错误状态

        // 重新读取一行作为顺序表B的数据
        getline(cin, line);
        stringstream ssbd(line); // 创建一个新的stringstream对象专门用于B
        while (ssbd >> tdb) vdb.push_back(tdb);// 确保将变量t添加到vib中

        printVector(vda);
        printVector(vdb);
        cout<<endl;
        Intersect_Sq_OL_C(vda,vdb,vdc);
        printVector(vdc);
        break;
    }
    case 2:
    {
        vector<char> vca,vcb,vcc;
        char tca,tcb;
        // 读取A的内容
        while (ss >> tca) vca.push_back(tca);
        cin.clear(); // 清除cin的错误状态

        // 重新读取一行作为顺序表B的数据
        getline(cin, line);
        stringstream ssbc(line); // 创建一个新的stringstream对象专门用于B
        while (ssbc >> tcb) vcb.push_back(tcb);// 确保将变量t添加到vib中

        printVector(vca);
        printVector(vcb);
        cout<<endl;
        Intersect_Sq_OL_C(vca,vcb,vcc);
        printVector(vcc);
        break;
    }
    case 3:
    {
        vector<string> vsa,vsb,vsc;
       string tsa,tsb;
        // 读取A的内容
        while (ss >> tsa) vsa.push_back(tsa);
        cin.clear(); // 清除cin的错误状态

        // 重新读取一行作为顺序表B的数据
        getline(cin, line);
        stringstream ssbs(line); // 创建一个新的stringstream对象专门用于B
        while (ssbs >> tsb) vsb.push_back(tsb);// 确保将变量t添加到vib中

        printVector(vsa);
        printVector(vsb);
        cout<<endl;
        Intersect_Sq_OL_C(vsa,vsb,vsc);
        printVector(vsc);
        break;
    }
    default:
        cout << "err" << endl;
        break;
    }

    return 0;
}