【东华大学oj】循环链表ADT模板简单应用算法设计：循环链表的合并

循环链表ADT模板简单应用算法设计：循环链表的合并

时间限制: 1s

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

问题描述

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

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

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

应用1：假设2个线性表分别由带头结点的循环链表A和B存储。现要求设计一个算法，将A和B归并为一个线性表 。要求利用循环链表的特点，使用A和B的原存储空间，且合并后销毁B链表。

参考函数原型：

template<class ElemType>

void Merge_Cur_Linklist( CirLinkList<ElemType> &A, CirLinkList<ElemType> &B );

输入说明

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

第二行：第一个循环链表的数据元素（元素与元素之间以空格分隔）

第三行：第二个循环链表的数据元素（元素与元素之间以空格分隔）

输出说明

如第一行输入值为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 =L;
    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 =L;
    LNode<T>* tail = L;

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

template<typename T>
void DispList(LinkList<T> L)
{
    LNode<T> *p = L->next;
    if(p == L) return; // 空链表的情况
    do
    {
        cout << p->data;
        if (p->next != L)
        {
            cout << "->";
        }
        p = p->next;
    }
    while (p != L);
    cout << endl;
}
template<typename T>
void Merge_Cur_Linklist(LinkList<T> &A, LinkList<T> &B)
{
    if(!A || !B || A == B) return; // 防止无效输入或自我合并

    LNode<T> *pa = A;
    while(pa->next != A) pa = pa->next; // 找到A的尾节点

    LNode<T> *pb = B;
    while(pb->next != B) pb = pb->next; // 找到B的尾节点

    pa->next = B->next; // A的尾节点指向B的第一个元素
    pb->next = A; // B的尾节点指向A的头节点，完成合并

    B->next = B; //（可选）将B自身形成一个单独的循环，如果B不再使用
}

int main()
{
    int type;
    cin >> type;
    cin.ignore(); // 忽略之前留下的换行符
    switch(type)
    {
    case 0:
    {
        LinkList<int> A, B;
        InitList(A);
        InitList(B);
        // 读取A的内容
        CreateList(A);
        CreateList(B); // 重新读取一行作为顺序表B的数据

        DispList(A);
        DispList(B);
        cout << endl;
        Merge_Cur_Linklist(A,B);
        DispList(A);
        break;
    }
    case 1:
    {
        LinkList<double> A, B;
        InitList(A);
        InitList(B);
        // 读取A的内容
        CreateList(A);
        CreateList(B); // 重新读取一行作为顺序表B的数据

        DispList(A);
        DispList(B);
        cout << endl;
        Merge_Cur_Linklist(A,B);
        DispList(A);
        break;
    }
    case 2:
    {
        LinkList<char> A, B;
        InitList(A);
        InitList(B);
        // 读取A的内容
        CreateList(A);
        CreateList(B); // 重新读取一行作为顺序表B的数据

        DispList(A);
        DispList(B);
        cout << endl;
        Merge_Cur_Linklist(A,B);
        DispList(A);
        break;

    }
    case 3:
    {
        LinkList<string> A, B;
        InitList(A);
        InitList(B);
        // 读取A的内容
        CreateList(A);
        CreateList(B); // 重新读取一行作为顺序表B的数据

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

    return 0;
}