单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换

单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换

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

截止日期: 2022-06-30 23:55:00

问题描述 :

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

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

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

应用1：假设有一个带头结点的单链表A，现要求设计一个算法，实现单链表的就地逆置，即利用原表的存储空间实现表中前m 个元素和后n 个元素的互换。

参考函数原型：

template<class ElemType>

void Exchange_L( LinkList<ElemType> &L, int m );

单链表ADT原型如下：

/* 单链表的结点定义 */
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 ListTraverse() const;
};

输入说明 :

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

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

第三行：逆置位置m

输出说明 :

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

否则：

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

空行

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

输入范例 :

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

输出范例 :

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

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

---

用了ADT形式，可放心食用~

AC代码：

#include<iostream>
#include<vector>
#include<sstream>
#include<cstring>
using namespace std;
template<class ElemType>
//void Exchange_L( LinkList<ElemType> &L, int m );
//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//:public link<ElemType>
{
   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 ListTraverse() const;
};
template<class ElemType>
bool LinkList<ElemType>::ListTraverse()const
{
    auto t0=head->next;
    while(t0)
    {
        cout<<t0->data;
        t0=t0->next;
        if(t0!=0)cout<<"->";
    }
    cout<<endl;
}
template<class ElemType>
void LinkList<ElemType>::ListDestroy()
{
    LinkNode<ElemType> *t1=NULL;
    while(head)
    {
        t1=head->next;
        delete head;
        head=t1;
    }
}
template<class ElemType>
bool LinkList<ElemType>::InsTail( ElemType &e )
{
    auto t3=new LinkNode<ElemType>(e);
    if(!t3)
        return 0;
    tail->next=t3;
    tail=t3;
    return 1;
}
template<class ElemType>
void LinkList<ElemType>::CreateList_Tail(vector<ElemType> &A)
{
    auto t4=A.begin();
    while(t4!=A.end())
    {
      InsTail(*t4);
      t4++;
    }
}
template<class ElemType>
void shu(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 tt=L.GetHead();
    auto ww=L.GetTail();
    ww->next=tt->next;
    ww=tt;
    for(int i=1;i<=m;i++)
    {
        ww=tt->next;
        tt->next=ww->next;
    }
    ww->next=nullptr;
    L.ListTraverse();
}
int main()
{
    int type,m;
    string s;
    cin>>type;
    getchar();
    getline(cin,s);
    stringstream in(s);
    cin>>m;
    if(type!=0&&type!=1&&type!=2&&type!=3)
    {
        cout<<"err"<<endl;
    }
    else if(type==0)
    {
        LinkList<int>aa;
        vector<int>a;
        shu(in,a);
        aa.CreateList_Tail(a);
        Exchange_L(aa,m);
    }
    else if(type==1)
    {
        LinkList<double>bb;
        vector<double>b;
        shu(in,b);
        bb.CreateList_Tail(b);
        Exchange_L(bb,m);
    }
    else if(type==2)
    {
        LinkList<char>cc;
        vector<char>c;
        shu(in,c);
        cc.CreateList_Tail(c);
        Exchange_L(cc,m);
    }
    else if(type==3)
    {
        LinkList<string>dd;
        vector<string>d;
        shu(in,d);
        dd.CreateList_Tail(d);
        Exchange_L(dd,m);
    }
    return 0;
}