DHU数据结构-单链表-ADT应用-单链表按要求提纯链表

目录

1.题目

2.题解

3.代码实现

---

1.题目

单链表ADT模板简单应用算法设计：按要求提纯链表

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

问题描述 :

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

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

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

应用：假设用单链表 A存储m个整数，结点的结构为(data,next)，且|data|<=N（N为正整数）。现要求设计一个时间复杂度尽可能高效的算法，对于链表A中的数据元素data的绝对值相等的结点，仅保留第一次出现的结点而删除其余绝对值相等的结点。

参考函数原型：

template<class ElemType>
void Delete_Equal_Node( LinkList<ElemType> &A, int N ); 

输入说明 :

第一行：限定值N  （以空格分隔）

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

输出说明 :

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

空行

第二行：按要求提纯后单链表A的遍历结果

输入范例 :

30
21 -15 -15 -7 15

输出范例 :

21->-15->-15->-7->15

21->-15->-7

---

2.题解

• 挖坑

---

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;
          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 Purge_Lk_OL( LinkList<ElemType> &L,int n)
  {
      L.ListTraverse();
      cout<<endl;
  
      auto i=L.GetHead()->next;
      auto k=L.GetHead();
      while(i)
      {
          auto j=L.GetHead()->next;
          int flag=0;
          while((i->data != j->data  &&  i->data != (-1)*(j->data)) && j!=(k->next))
          {
              if(j==k)flag=1;
              j=j->next;
          }
          if(k==L.GetHead() || flag)
          {
              k->next=i;
              k=k->next;
          }
  
          i=i->next;
      }
  
      k->next=nullptr;
      L.ListTraverse();
  
  }
  int main()
  {
      int n;
      string s;
      cin>>n;
      getchar();
      getline(cin,s);
      stringstream in(s);
  
      LinkList<int> a;
      vector<int> A;
      f(in,A);
      a.CreateList_Tail(A);
      Purge_Lk_OL(a,n);
  
      return 0;
  }