DHU数据结构-单链表-ADT应用-2个单链表的交叉归并

目录

1.题目

2.题解

3.代码实现

---

1.题目

3 单链表ADT模板简单应用算法设计：2个单链表的交叉归并

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

问题描述 :

目的：使用C++模板设计单链表的抽象数据类型（ADT）。并在此基础上，使用单链表ADT的基本操作，设计并实现单链表的简单算法设计。

内容：（1）请使用模板设计单链表的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考网盘中的ADT原型文件。）

（2）ADT的简单应用：使用该ADT设计并实现单链表应用场合的一些简单算法设计。

应用3：假设线性表A=(a1,a2,...,am)，线性表B=(b1,b2,...,bn)，现要求设计一个算法，使用带头结点的单链表存储结构，按照下列规则合并A、B为线性表C。即：A和B的元素间隔排列，且使用A和B的原存储空间，且B不再单独存在。输入中的单链表的长度不得在该算法中利用，仅作为建表使用。

参考函数原型：

template<class ElemType>

void Merge_L( LinkList<ElemType> &A, LinkList<ElemType> &B );

输入说明 :

第一行：顺序表A的数据元素的数据类型标记（0：int，1：double，2：char，3：string）

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

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

输出说明 :

如第一行输入值为0、1、2、3之外的值，直接输出“err”

否则：

第一行：单链表A的遍历结果（数据元素之间以"->"分隔）

第二行：单链表B的遍历结果（数据元素之间以"->"分隔）

空行

第三行：交叉归并后单链表A的遍历结果（数据元素之间以"->"分隔）

输入范例 :

4
I am a student.
You are also a student.

输出范例 :

err

---

2.题解

• 读题：adt实现单链表及其简单算法+实现两个单链表交叉归并算法
• adt
• 2个单链表交叉归并：

---

3.代码实现

• 交叉归并

  template<class ElemType>
  void Merge_L( LinkList<ElemType> &A, LinkList<ElemType> &B )
  {
      A.ListTraverse();
      B.ListTraverse();
      cout<<endl;
  
      auto p=A.GetHead()->next;//指向A表的首元节点,p用来遍历A和B两个表（作为一根线把两表交叉穿起来）
      auto t=p->next;//t是临时存储下个要用线穿起来的节点，而B.GetHead()->next用来指向当前要被线穿起来的节点
      while(p&&B.GetHead()->next)
      {
          t=p->next;//存储下个穿入的节点
          p->next=B.GetHead()->next;//把当前节点穿入线中
          p=p->next;//维护已经穿好的所有节点中最新节点的指针
          B.GetHead()->next=t;//把原来下个要穿入的节点作为马上要被穿入的节点
      }
  
      A.ListTraverse();
  }
  

• 完整代码

  #include <iostream>
  #include <sstream>
  #include <cstring>
  #include <vector>
  
  using namespace std;
  
  /* 单链表的结点定义 */
  template<class ElemType>
  struct LinkNode
  {
      ElemType data;
      LinkNode<ElemType> *next;
      LinkNode(LinkNode<ElemType> *ptr = NULL){next = ptr;}
      LinkNode(const ElemType &item, LinkNode<ElemType> *ptr = NULL)
      //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
      {
          next = ptr;
          data = item;
      }
  };
  
  //带头结点的单链表
  template<class ElemType>
  class LinkList
  {
     private:;
        LinkNode<ElemType> *head;   // 头指针
        LinkNode<ElemType> *tail;   // 尾指针
     public:
        //无参数的构造函数
        LinkList(){head = new LinkNode<ElemType>; tail =head;}
        //带参数的构造函数
        LinkList(const ElemType &item){head = new LinkNode<ElemType>(item); tail = head;}
        //拷贝构造函数
        LinkList(LinkList<ElemType> &List);
        //析构函数
        ~LinkList(){ListDestroy();}
        //重载函数:赋值
        LinkList<ElemType>& operator=(LinkList<ElemType> &List);
        //销毁链表
        void ListDestroy();
        //清空链表
        void ListClear();
        //返回链表的长度
        int ListLength() const;
        //判断链表是否为空表
        bool ListEmpty() const;
        //在首结点之前插入一个结点
        bool InsFirst( ElemType &e );
        //在尾结点之前插入一个结点
        bool InsTail( ElemType &e );
        //获取链表头指针
        LinkNode<ElemType>* GetHead() const{ return head;}
        //获取链表尾指针
        LinkNode<ElemType>* GetTail() const{ return tail;}
        //设置链表头指针
        void SetHead(LinkNode<ElemType> *p){ head = p;}
        //设置链表尾指针
        void SetTail(LinkNode<ElemType> *p){ tail = p;}
        //用e返回链表的第i个元素
        ElemType GetElem(int pos);
        //在链表的第pos个位置之前插入e元素
        bool ListInsert(int pos,ElemType e);
        //删除链表的首结点
        //bool DelFirst( ElemType &e);
        //表头插入法动态生成链表
        void CreateList_Head(vector<ElemType> &A);
        //表尾插入法动态生成链表
        void CreateList_Tail(vector<ElemType> &A);
        //删除链表的第pos个位置的元素
        ElemType ListDelete(int pos);
        //compare函数，用来判断a和b是否相等
        //bool compare(ElemType a, ElemType *b);
        //按指定条件查找，返回指向第一个符合条件（=e）的元素的指针
        bool LocateElem(const ElemType &e, LinkNode<ElemType> * &pos);
        //返回链表给定数据元素的前驱数据元素的值
        //bool PriorElem(ElemType cur_e, ElemType &pri_e);
        //返回链表给定数据元素的后继数据元素的值
        bool NextElem(LinkNode<ElemType> *p, ElemType &e);
        //遍历链表(老师写的是bool，为啥不是void)
        //bool ListTraverse() const;
        void ListTraverse() const;
  };
  template<class ElemType>
  void LinkList<ElemType>::ListTraverse() const
  {
      auto temp=head->next;
      while(temp)
      {
          cout<<temp->data;
          temp=temp->next;
          if(temp)cout<<"->";
      }
      cout<<endl;
  }
  template<class ElemType>
  void LinkList<ElemType>::ListDestroy()
  {
      auto temp=head;
      while(temp)
      {
          delete head;
          temp=temp->next;
      }
  }
  template<class ElemType>
  bool LinkList<ElemType>::InsTail( ElemType &e )
  {
      auto temp=new LinkNode<ElemType>(e);
      if(!temp)return false;
      tail->next=temp;
      tail=temp;
      return true;
  }
  template<class ElemType>
  void LinkList<ElemType>::CreateList_Tail(vector<ElemType> &A)
  {
      auto it=A.begin();
      for(;it!=A.end();it++)
          InsTail(*it);
  }
  
  
  //暂时存储输入的数据，之后通过造表函数造成单链表
  template<class ElemType>
  void f(stringstream &in,vector<ElemType> &t)
  {
      ElemType str;
      while(in>>str)t.push_back(str);
  }
  template<class ElemType>
  void Merge_L( LinkList<ElemType> &A, LinkList<ElemType> &B )
  {
      A.ListTraverse();
      B.ListTraverse();
      cout<<endl;
  
      auto p=A.GetHead()->next;//指向A表的首元节点,p用来遍历A和B两个表（作为一根线把两表交叉穿起来）
      auto t=p;//t是临时存储下个要用线穿起来的节点，而B.GetHead()->next用来指向当前要被线穿起来的节点
      while(p&&B.GetHead()->next)
      {
          t=p->next;//存储下个穿入的节点
          p->next=B.GetHead()->next;//把当前节点穿入线中
          p=p->next;//维护已经穿好的所有节点中最新节点的指针
          B.GetHead()->next=t;//把原来下个要穿入的节点作为马上要被穿入的节点
      }
  
      A.ListTraverse();
  }
  int main()
  {
      int n;
      string s1,s2;
      cin>>n;
      getchar();
      getline(cin,s1);
      getline(cin,s2);
      stringstream in1(s1);
      stringstream in2(s2);
  
      if(n==0)
      {
          LinkList<int> a1,a2;
          vector<int> A1,A2;
          f(in1,A1);
          f(in2,A2);
          a1.CreateList_Tail(A1);
          a2.CreateList_Tail(A2);
          Merge_L(a1,a2);
      }
      else if(n==1)
      {
          LinkList<double> b1,b2;
          vector<double> B1,B2;
          f(in1,B1);
          f(in2,B2);
          b1.CreateList_Tail(B1);
          b2.CreateList_Tail(B2);
          Merge_L(b1,b2);
      }
      else if(n==2)
      {
          LinkList<char> c1,c2;
          vector<char> C1,C2;
          f(in1,C1);
          f(in2,C2);
          c1.CreateList_Tail(C1);
          c2.CreateList_Tail(C2);
          Merge_L(c1,c2);
      }
      else if(n==3)
      {
          LinkList<string> d1,d2;
          vector<string> D1,D2;
          f(in1,D1);
          f(in2,D2);
          d1.CreateList_Tail(D1);
          d2.CreateList_Tail(D2);
          Merge_L(d1,d2);
      }
      else cout<<"err"<<endl;
  
      return 0;
  }