【东华大学oj】单链表ADT模板简单应用算法设计：单链表中前 m 个元素和后 n 个元素的互换

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

时间限制: 1s

类别: DS：线性表->链式线性表--简单

问题描述

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

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

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

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

参考函数原型：

template<class ElemType>

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

输入说明

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

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

第三行：逆置位置m

输出说明

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

否则：

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

空行

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

#include <iostream>
#include <sstream>
#include <string>
#include <iomanip>
using namespace std;
//定义链式线性表
template<typename T>
struct LNode
{
    T data;
    LNode *next;
};

template<typename T>
using LinkList = LNode<T>*;

//初始化链表
template<typename T>
bool InitList(LinkList<T>& L)
{
    L = new LNode<T>;
    L->next = NULL;
    return true;
}
template<typename T>
void CreateList(LinkList<T> &L)
{
    string line;
    T value;
    getline(cin, line);
    istringstream iss(line);

    L = new LNode<T>;
    L->next = NULL;
    LNode<T>* tail = L;

    while (iss >> value)
    {
        LNode<T>* newNode = new LNode<T>;
        newNode->data = value;
        newNode->next = NULL;
        tail->next = newNode;
        tail = newNode;
    }
}

template<typename T>
void DispList(LinkList<T> L)
{
    LNode<T> *p = L->next;
    while (p != NULL)
    {
        cout << p->data;
        if (p->next != NULL)
        {
            cout << "->";
        }
        p = p->next;
    }
    cout << endl;
}

template<typename T>
void Exchange_L( LinkList<T> &A, int m )
{
    LNode<T>*pa=A->next,*pc=A;
    for(int i=0; i<m; ++i)
    {
        pc=pa;
        pa=pa->next;
    }
    while(pa->next!=nullptr) pa=pa->next;
    pa->next=A->next;
    A->next=pc->next;
    pc->next=nullptr;

}

int main()
{
    int type;
    int m;
    cin >> type;
    cin.ignore(); // 忽略之前留下的换行符
    switch(type)
    {
    case 0:
    {
        LinkList<int> A;
        InitList(A);

        // 读取A的内容
        CreateList(A);
        cin>>m;

        DispList(A);

        cout << endl;
        Exchange_L(A,m );
        DispList(A);
        break;
    }
    case 1:
    {
        LinkList<double> A;
        InitList(A);

        // 读取A的内容
        CreateList(A);
        cin>>m;

        DispList(A);

        cout << endl;
        Exchange_L(A, m );
        DispList(A);
        break;
    }
    case 2:
    {
        LinkList<char> A;
        InitList(A);

        // 读取A的内容
        CreateList(A);
        cin>>m;

        DispList(A);

        cout << endl;
        Exchange_L(A, m );
        DispList(A);
        break;

    }
    case 3:
    {
        LinkList<string> A;
        InitList(A);

        // 读取A的内容
        CreateList(A);
        cin>>m;
        DispList(A);

        cout << endl;
        Exchange_L(A,m );
        DispList(A);
        break;
    }
    default:
    {
        cout << "err" << endl;
    }
    }

    return 0;
}