DHU数据结构-单链表-ADT应用-单链表指定结点的移动

目录

1.题目

2.题解

3.代码实现

---

1.题目

单链表指定结点的移动

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

问题描述 :

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

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

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

应用2：设计一个算法，使用带头结点的单链表存储结构，将链表中数值域值最小的那个结点移到链表的最前面。要求：不得额外申请新的结点。

参考函数原型：

template<class ElemType>

void Linklist_MoveMinToFirst( LinkList<ElemType> &A );

输入说明 :

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

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

输出说明 :

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

否则：

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

空行

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

输入范例 :

0
13 5 27 9 32 123 76 98 54 87

输出范例 :

13->5->27->9->32->123->76->98->54->87

5->13->27->9->32->123->76->98->54->87

---

2.题解

• 挖坑

---

3.代码实现

• 1

  #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 Exchange_L( LinkList<ElemType> &L, int m )
  {
      L.ListTraverse();
      cout<<endl;
  
      auto t=L.GetHead()->next;
      auto res=t;
      auto res_pre=L.GetHead();
      auto t_pre=res_pre;
      while(t)
      {
          if(t->data < res->data)
          {
              res=t;
              res_pre=t_pre;
          }
          t_pre=t;
          t=t->next;
      }
  
      res_pre->next=res->next;
      res->next=L.GetHead()->next;
      L.GetHead()->next=res;
  
      L.ListTraverse();
  }
  int main()
  {
      int n,m;
      string s;
      cin>>n;
      getchar();
      getline(cin,s);
      stringstream in(s);
  
      if(n==0)
      {
          LinkList<int> a;
          vector<int> A;
          f(in,A);
          a.CreateList_Tail(A);
          Exchange_L(a,m);
      }
      else if(n==1)
      {
          LinkList<double> b;
          vector<double> B;
          f(in,B);
          b.CreateList_Tail(B);
          Exchange_L(b,m);
      }
      else if(n==2)
      {
          LinkList<char> c;
          vector<char> C;
          f(in,C);
          c.CreateList_Tail(C);
          Exchange_L(c,m);
      }
      else if(n==3)
      {
          LinkList<string> d;
          vector<string> D;
          f(in,D);
          d.CreateList_Tail(D);
          Exchange_L(d,m);
      }
      else cout<<"err"<<endl;
  
      return 0;
  }