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

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

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

问题描述 :

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

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

应用1：假设有一个带头结点的单链表A，现要求设计一个算法，实现单链表的就地逆置，即利用原表的存储空间实现表中前m 个元素和后n 个元素的互换。
参考函数原型：
template
void Exchange_L( LinkList &L, int m );

单链表ADT原型如下：

/* 单链表的结点定义 */
template
struct LinkNode
{
ElemType data;
LinkNode *next;
LinkNode(LinkNode *ptr = NULL){next = ptr;}
LinkNode(const ElemType &item, LinkNode *ptr = NULL)
//函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
{
next = ptr;
data = item;
}
};
//带头结点的单链表
template
class LinkList:public link
{
private:
LinkNode head; // 头指针
LinkNode tail; // 尾指针
public:
//无参数的构造函数
LinkList(){head = new LinkNode; tail =head;}
//带参数的构造函数
LinkList(const ElemType &item){head = new LinkNode(item); tail = head;}
//拷贝构造函数
LinkList(LinkList &List);
//析构函数
~LinkList(){ListDestroy();}
//重载函数:赋值
LinkList& operator=(LinkList &List);
//销毁链表
void ListDestroy();
//清空链表
void ListClear();
//返回链表的长度
int ListLength() const;
//判断链表是否为空表
bool ListEmpty() const;
//在首结点之前插入一个结点
bool InsFirst( ElemType &e );
//在尾结点之前插入一个结点
bool InsTail( ElemType &e );
//获取链表头指针
LinkNode GetHead() const{ return head;}
//获取链表尾指针
LinkNode GetTail() const{ return tail;}
//设置链表头指针
void SetHead(LinkNode *p){ head = p;}
//设置链表尾指针
void SetTail(LinkNode *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 &A);
//表尾插入法动态生成链表
void CreateList_Tail(vector &A);
//删除链表的第pos个位置的元素
ElemType ListDelete(int pos);
//compare函数，用来判断a和b是否相等
//bool compare(ElemType a, ElemType *b);
//按指定条件查找，返回指向第一个符合条件（=e）的元素的指针
bool LocateElem(const ElemType &e, LinkNode * &pos);
//返回链表给定数据元素的前驱数据元素的值
//bool PriorElem(ElemType cur_e, ElemType &pri_e);
//返回链表给定数据元素的后继数据元素的值
bool NextElem(LinkNode *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

输出范例中间有一行空行的打不出来了

！！！
⚠️如果是另一个思路 把前m个拿出来放在另一个链表里 再把这个链表连在原来的链表上的话 析构的时候就会析构两次！因为连成了一个所以后析构已经把后面的那个析构了 再析构第一个的时候就会出现错误
！！！

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
/* 单链表的结点定义 */
template<class ElemType>
struct Node
{
    ElemType data;
    Node<ElemType> *next;
    Node(Node<ElemType> *ptr = NULL)
    {
        next = ptr;   //构造函数1，用于构Node造头结点
    }
    Node(const ElemType &item, Node<ElemType> *ptr = NULL) //构造函数2，用于构造其他结点
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = item;
    }
};
template<class ElemType>
class LinkList {

private:
    Node<ElemType> *head;   // 头指针
    Node<ElemType> *tail;   // 尾指针
public:
    //以下定义两个类型，可以看出，Link和Position类型完全相同，
    //只是Link类型被认为指向一个链表，Position类型被认为指向某个位置的结点
    typedef struct Node<ElemType> *Link;
    typedef struct Node<ElemType> *Position;

    //无参数的构造函数
    LinkList() {
        head = new Node<ElemType>;
        tail = head;
    }

    //带参数的构造函数
    LinkList(const ElemType &item) {
        head = new Node<ElemType>;
        head->next = tail = new Node<ElemType>(item);
    }

    //析构函数
    ~LinkList() {
        Destroy();
    }

    //重载函数:赋值
    LinkList<ElemType> operator=(LinkList<ElemType> &List);

    //拷贝构造函数
    LinkList(const LinkList<ElemType> &List);

    //销毁链表中所有结点，释放内存
    void Destroy();

    //尾插入
    bool ListInsert_Pop(ElemType e);

    //获取链表头结点指针
    Link GetHead()
    {
        return head;
    }

    //遍历链表
    bool ListTraverse() const;

    //删除链表中首元结点，并用q返回被删除的结点
    bool ListDeleteFirst(Position &q);

    //将s所指向的链表（一串结点）附加到本链表的尾部
    bool Append(Node<ElemType> *s);
};

//重载函数:赋值
template<class ElemType>
LinkList<ElemType> LinkList<ElemType>::operator=(LinkList<ElemType> &List)
{
    head = new Node<ElemType>;
    tail=head;
    Node<ElemType> *r;	//r为指向尾结点的指针
    r = tail;

    Node<ElemType> *p=List.head->next;	//p为指向待插入结点的指针

    while(p)
    {
        Node<ElemType> *q = new Node<ElemType>;
        q->data = p->data;
        r->next = q;
        r = q;
        p=p->next;
    }
    r->next = NULL;
    tail = r;
    return *this;
}
//拷贝构造函数
template<class ElemType>
LinkList<ElemType>::LinkList(const LinkList<ElemType> &List)
{
    head = new Node<ElemType>;
    tail=head;
    Node<ElemType> *r;	//r为指向尾结点的指针/
    r = tail;

    Node<ElemType> *p=List.head->next;	//p为指向待插入结点的指针

    while(p)
    {
        Node<ElemType> *q = new Node<ElemType>;
        q->data = p->data;
        r->next = q;
        r = q;
        p=p->next;
    }
    r->next = NULL;
    tail = r;
}
template<class ElemType>
bool LinkList<ElemType>::ListInsert_Pop( ElemType e )
{
    Node<ElemType> *s;
    s = new Node<ElemType>;
    s->data = e;    // 创建新元素的结点
    if(!s)
        return false;
    if(tail == NULL)
    {
        tail = head->next;
        tail = s;
    }
    else
    {
        tail->next = s;
        tail = s;
    }
    tail->next=NULL;
    return true;
}
template<class ElemType>
bool LinkList<ElemType>::ListTraverse() const
{
    //遍历链表
    Node<ElemType> *p;
    p = head->next;
    while( p )
    {
        if(p == tail)
        {
            cout<<p->data;
            p = p->next;
        }
        else
        {
            cout << p->data << "->";
            p = p->next;
        }
    }  // while
    cout<<endl;
    return true;
}
template<class ElemType>
void LinkList<ElemType>::Destroy()
{
    //销毁以head为头指针的单链表，释放链表中所有结点空间
    Node<ElemType> *p;
    while( head)
    {
        p = head;
        head = head->next;
        delete p;
    }
    head = NULL;
}
template<class ElemType>
bool LinkList<ElemType>:: ListDeleteFirst(Position &q)
{
    if (head == NULL) return false;
    if (head->next != NULL)
    {
        q=head->next;
        head->next = q->next;
        q->next=NULL;
        if (tail == q) tail = head;  //删除了唯一的一个结点
        return true;
    }
    else
    {
        q=NULL;
        return false;
    }
}
template<class ElemType>
bool LinkList<ElemType>:: Append(Node<ElemType>* s)
{
    if (tail==NULL)
        return false;
    tail -> next = s->next;
    Node<ElemType> *p;
    p = s;
    while( p->next )
    {
        p = p->next;
    }  // while
    tail = p;
    tail -> next = NULL;
    return true;
}
template<class ElemType>
void Exchange_L( LinkList<ElemType> &l, int m )
{
    Node<ElemType> *t;
    t = new Node<ElemType>;
    int count = 0;
    while(count < m)
    {
        l.ListDeleteFirst(t);
        l.ListInsert_Pop(t->data);
        count++;
    }
}

template<class ElemType>
void Cin_int(LinkList<ElemType> &x)
{
    string s;
    getline(cin,s);
    int num = 0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            x.ListInsert_Pop(num);
            num = 0;
        }
        else
        {
            num = num * 10 + s[i]-'0';
        }
    }
    x.ListInsert_Pop(num);
}
template<class ElemType>
void Cin_double(LinkList<ElemType> &x)
{
    string s;
    getline(cin,s);
    bool flag = false;
    int t=0;
    double num = 0.0;
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            num = num / pow(10,t);
            x.ListInsert_Pop(num);
            t=0;
            flag = false;
            num = 0;
        }
        else if(s[i] == '.')
        {
            flag = true;
        }
        else
        {
            if(flag)
                t++;
            num = num * 10 + s[i] - '0';
        }
    }
    num = num / pow(10,t);
    x.ListInsert_Pop(num);
}
template<class ElemType>
void Cin_char(LinkList<ElemType> &x)
{
    string s;
    getline(cin,s);
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
            continue;
        else
            x.ListInsert_Pop(s[i]);
    }
}
template<class ElemType>
void Cin_string(LinkList<ElemType> &x)
{
    string s,t;
    getline(cin,s);
    for(int i=0;i<s.size();i++)
    {
        if(s[i] == ' ')
        {
            x.ListInsert_Pop(t);
            t.clear();
        }
        else
        {
            t+=s[i];
        }
    }
    x.ListInsert_Pop(t);
}
int main()
{
    int x,m;
    cin>>x;
    getchar();
    switch(x)
    {
        case 0:
        {
            LinkList<int> z0;
            Cin_int(z0);
            cin>>m;
            z0.ListTraverse();
            cout<<endl;
            Exchange_L( z0, m );
            z0.ListTraverse();
            break;
        }
        case 1:
        {
            LinkList<double> z1;
            LinkList<double> a1;
            Cin_double(z1);
            cin>>m;
            z1.ListTraverse();
            cout<<endl;
            Exchange_L( z1, m );
            z1.ListTraverse();
            break;
        }
        case 2:
        {
            LinkList<char> z2;
            LinkList<char> a2;
            Cin_char(z2);
            cin>>m;
            z2.ListTraverse();
            cout<<endl;
            Exchange_L( z2,m );
            z2.ListTraverse();
            break;
        }
        case 3:
        {
            LinkList<string> z3;
            LinkList<string> a3;
            Cin_string(z3);
            cin>>m;
            z3.ListTraverse();
            cout<<endl;
            Exchange_L( z3, m );
            z3.ListTraverse();
            break;
        }
        default:
            cout<<"err"<<endl;
    }
    return 0;
}