【东华大学oj】单链表ADT模板简单应用算法设计：有序单链表的归并+提纯

单链表ADT模板简单应用算法设计：有序单链表的归并+提纯

时间限制: 1s

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

问题描述

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

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

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

应用6：假设2个线性表分别由单链表A和B存储，其中数据元素按值非递减有序排列（即已经有序），现要求设计一个算法，将A和B归并为一个线性表 , 其数据元素仍按值非递减排列，且表中不存在值相同的元素。要求使用A和B的原存储空间，且B不再单独存在。

参考函数原型：

template<class ElemType>

void Merge_L_Pure_Order( LinkList<ElemType> &A, LinkList<ElemType> &B );

输入说明

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

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

输出说明

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

否则：

第一行：单链表A的遍历结果

第二行：单链表B的遍历结果

空行

第四行：归并+提纯后单链表A的遍历结果

#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<>
void DispList<double>(LinkList<double> L)
{
    LNode<double> *p = L->next;
    while (p != NULL)
    {
        cout << fixed << setprecision(1) << p->data; // Use fixed and setprecision to display .0
        if (p->next != NULL)
        {
            cout << "->";
        }
        p = p->next;
    }
    cout << endl;
}
template<typename T>
void Merge_L_Pure_Order(LinkList<T> &A, LinkList<T> &B)
{
    LNode<T> *pa = A->next, *pb = B->next, *pc = A, *temp;

    while (pa && pb)
    {
        if (pa->data < pb->data)
        {
            if (pc == A || pc->data != pa->data)
            {
                pc->next = pa;
                pc = pa;
            }
            pa = pa->next;
        }
        else if (pa->data > pb->data)
        {
            if (pc == A || pc->data != pb->data)
            {
                pc->next = pb;
                pc = pb;
            }
            pb = pb->next;
        }
        else     // 当元素相等时，只保留一个
        {
            if (pc == A || pc->data != pa->data)
            {
                pc->next = pa; // 保留A中的元素
                pc = pa;
            }
            pa = pa->next;
            temp = pb; // 删除B中的重复元素
            pb = pb->next;
            delete temp;
        }
    }

    while (pa)
    {
        if (pc->data != pa->data)
        {
            pc->next = pa;
            pc = pa;
        }
        pa = pa->next;
    }

    while (pb)
    {
        if (pc->data != pb->data)
        {
            pc->next = pb;
            pc = pb;
        }
        pb = pb->next;
    }

    pc->next = NULL;
    delete B; // 删除B的头结点
    B = nullptr; // 为防止悬挂指针
}

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_L_Pure_Order(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_L_Pure_Order(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_L_Pure_Order(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_L_Pure_Order(A, B);
        DispList(A);
        break;
    }
    default:
    {
        cout << "err" << endl;
    }
    }

    return 0;
}