DHU数据结构-顺序表- ADT应用-线性表的合并

目录

1.题目

2.题解

3.代码实现

---

1.题目

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

作者: 冯向阳 时间限制: 1S 章节: DS:线性表

问题描述 :

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

应用4：试设计一个算法，将所有在线性表LB中但不在LA中的数据元素插入到LA中,算法执行之后，线性表LB不再存在。

参考函数原型：

（2）顺序表ADT版本

template<class ElemType>
void Union_Sq( SqList<ElemType> &LA, SqList<ElemType> &LB )；

（2）vector版本

template<class ElemType>
void Union_Sq( vector<ElemType> &LA, vector<ElemType> &LB )；

输入说明 :

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

第二行：待处理顺序表LA的数据元素（数据元素之间以空格分隔）

第三行：待处理顺序表LB的数据元素（数据元素之间以空格分隔）

输出说明 :

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

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

空行

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

输入范例 :

0
13 5 27 9 32 123 76 98 54 87
13 5 13 9 32 51 76 5 54 8

输出范例 :

13,5,27,9,32,123,76,98,54,87
13,5,13,9,32,51,76,5,54,8

13,5,27,9,32,123,76,98,54,87,51,8

---

2.题解

• 读题：实现顺序表+实现顺序表的并集操作
• 造表：stringstream好用的很
• 并集算法：方法一，比较容易想到但是可能复杂度会高；遍历B表，每个B表元素都在A表中寻找是否有相同元素，然后判断是否插入。方法二，运用树的知识，使用树来实现并查集可以把复杂度降低

---

3.代码实现

• 造表（stringstream或者分类型读入）

  template<class T>
  void creatlist(stringstream &input,vector<T> &A)
  {
      string str;
      while(input>>str) A.push_back(str);
  }
  
  int main()
  {
      cin>>n;
      getchar()
      getline(cin,s1);
      getline(cin,s2);
      
      if(n==0)
      {
          vector<int> a1,a2;
          creatlist(s1,a1);
          creatlist(s2,a2);
          merge(a1,a2);
      }
      else if(n==1)
      {
          vector<double> b1,b2;
          creatlist(s1,b1);
          creatlist(s2,b2);
          merge(b1,b2);
      }
      else if(n==2)
      {
          vector<char> c1,c2;
          creatlist(s1,c1);
          creatlist(s2,c2);
          merge(c1,c2);
      }
      else if(n==3)
      {
          vector<string> d1,d2;
          creatlist(s1,d1);
          creatlist(s2,d2);
          merge(d1,d2);
      }
      else cout<<"err"<<endl;
      
      return 0;
  }

• 算法

  //方法一：遍历查找
  template<class T>
  void print(vector<T> &A)
  {
      if(A.size()==0)
      {
          cout<<"NULL"<<endl;
          return;
      }
      int i;
      for(i=0; i<A.size()-1; i++)
          cout<<A[i]<<",";
      cout<<A[i]<<endl;
  }
  template<class T>
  void merg(vector<T> &a,vector<T> &b)
  {
      print(a);
      print(b);
      cout<<endl;
  
      for(int i=0;i<b.size();i++)
      {
          auto it=find(a.begin(),a.end(),b[i]);//因为vector中的find是朴素查找，所以复杂度是O(n)
          if(it==a.end()) a.push_back(b[i]);
      }
      print(a);
  }
  
  
  //方法二：并查集
  突然觉得并查集并不适用，因为并查集是在线找+查两个动作，而且只有集合（不存在重复元素）才能用，而题目并未保证线性表是集合的样子，所以不适用好像。我再试试之后更新

• 完整代码

#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;
int n;
string s1,s2;

template<class T>
void print(vector<T> &A)
{
    if(A.size()==0)
    {
        cout<<"NULL"<<endl;
        return;
    }
    int i;
    for(i=0; i<A.size()-1; i++)
        cout<<A[i]<<",";
    cout<<A[i]<<endl;
}
template<class T>
void merg(vector<T> &a,vector<T> &b)
{
    print(a);
    print(b);
    cout<<endl;

    for(int i=0;i<b.size();i++)
    {
        auto it=find(a.begin(),a.end(),b[i]);
        if(it==a.end()) a.push_back(b[i]);
    }
    print(a);
}


vector<int> f0(string s)
{
    vector<int> a;
    int num=0;
    for(int i=0; i<s.size(); i++)
    {
        if(s[i]==' ')
        {
            a.push_back(num);
            num=0;
        }
        else
        {
            num=num*10+s[i]-'0';
        }
    }
    a.push_back(num);
    return a;
}

vector<double> f1(string s)
{
    vector<double> b;
    double num=0;
    int flag=0,t=0;
    for(int i=0; i<s.size(); i++)
    {
        if(s[i]==' ')
        {
            num=num/pow(10,t);
            b.push_back(num);
            t=0,num=0,flag=0;
        }
        else if(s[i]=='.')
        {
            flag=1;
        }
        else
        {
            num=num*10+s[i]-'0';
            if(flag==1)
                t++;
        }
    }
    num=num/pow(10,t);
    b.push_back(num);
    return b;
}

vector<char> f2(string s)
{
    vector<char> c;
    for(int i=0; i<s.size(); i++)
    {
        if(s[i]!=' ')
            c.push_back(s[i]);
    }
    return c;
}

vector<string> f3(string s)
{
    vector<string> d;
    string str;
    str.clear();
    for(int i=0; i<s.size(); i++)
    {
        if(s[i]==' ')
        {
            d.push_back(str);
            str.clear();
        }
        else
            str+=s[i];
    }
    if(str!="") d.push_back(str);
    return d;
}

int main()
{
    cin>>n;
    getchar();
    getline(cin,s1);
    getline(cin,s2);

    if(n==0)
    {
        vector<int> A1,A2;
        A1=f0(s1);
        A2=f0(s2);
        merg(A1,A2);
    }
    else if(n==1)
    {
        vector<double> B1,B2;
        B1=f1(s1);
        B2=f1(s2);
        merg(B1,B2);
    }
    else if(n==2)
    {
        vector<char> C1,C2;
        C1=f2(s1);
        C2=f2(s2);
        merg(C1,C2);
    }
    else if(n==3)
    {
        vector<string> D1,D2;
        D1=f3(s1);
        D2=f3(s2);
        merg(D1,D2);
    }
    else
        cout<<"err"<<endl;

    return 0;
}

---