DHU数据结构-单链表-ADT应用-有序单链表的归并（提纯）

目录

1.题目

2.题解

3.代码实现

---

1.题目

单链表ADT模板简单应用算法设计：有序单链表的归并（提纯）

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

问题描述 :

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

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

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

应用：假设线性表 A和B，分别由单链表 La和Lb 存储，其中数据元素为整数，按值非递减有序排列（即已经有序），现要求设计一个算法，将A和B归并为一个线性表 , 其数据元素仍按值非递减排列。如果两个表中存在相等的元素，则只保留A中的元素，删除B中对应的元素，以确保合并后的表中无重复的元素。要求使用A和B的原存储空间，且B不再单独存在。输入中的单链表的长度不得在归并算法中利用，仅作为建表使用。（本质：求A和B的交集）

参考函数原型：

template<class ElemType>

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

输入说明 :

第一行：单链表A的长度

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

第三行：单链表B的长度

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

输出说明 :

第一行：单链表A的遍历结果

第二行：单链表B的遍历结果

第三行：归并后单链表A的遍历结果

输入范例 :

4
3 5 8 11
5
2 6 8 9 11

输出范例 :

3 5 8 11 
2 6 8 9 11 

2 3 5 6 8 9 11 

---

2.题解

• 挖坑，3天内填完，等我把这几题全做完吧

---

3.代码实现

• 完整代码

  #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;
      }
      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_Order( LinkList<ElemType> &A, LinkList<ElemType> &B )
  {
      //先排序后去重
      A.ListTraverse();
      B.ListTraverse();
      cout<<endl;
  
      auto ta=A.GetHead()->next;
      auto tb=B.GetHead()->next;
      auto t=A.GetHead();
      while(ta && tb)
      {
          if(ta->data < tb->data)
          {
              t->next=ta;
              t=t->next;
              ta=ta->next;
          }
          else
          {
              t->next=tb;
              t=t->next;
              tb=tb->next;
          }
      }
      if(ta) t->next=ta;
      if(tb) t->next=tb;
  
      auto front=A.GetHead()->next;
      auto back=A.GetHead()->next;
      while(back)
      {
          if(front->data != back->data)
          {
              front->next=back;
              front=front->next;
          }
          back=back->next;
      }
      front->next=nullptr;
  
  
      A.ListTraverse();
  
  }
  int main()
  {
      int la,lb;
      string s1,s2;
      vector<int> a,b;
      LinkList<int> A,B;
  
      cin>>la;
      getchar();
      getline(cin,s1);
      stringstream in1(s1);
      cin>>lb;
      getchar();
      getline(cin,s2);
      stringstream in2(s2);
  
      f(in1,a);
      f(in2,b);
      A.CreateList_Tail(a);
      B.CreateList_Tail(b);
  
      Merge_L_Order(A,B);
  
      return 0;
  }