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

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

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

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

问题描述 :

目的：使用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的遍历结果

输入范例 :

0
3 3 5 5 8 8 11 11
2 2 6 8 8 9 11

输出范例 :

3->3->5->5->8->8->11->11
2->2->6->8->8->9->11

2->3->5->6->8->9->11

---

用了链表的ADT形式，可放心食用~

AC代码：

#include<iostream>
#include<sstream>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
/* 单链表的结点定义 */
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，为啥不是void)
    //bool ListTraverse() const;
    void ListTraverse() const;
};
template<class ElemType>
void LinkList<ElemType>::ListTraverse() const
{
    auto temp=head->next;
    while(temp)
    {
        cout<<temp->data;
        temp=temp->next;
        if(temp)
            cout<<"->";
    }
    cout<<endl;
}
template<class ElemType>
void LinkList<ElemType>::ListDestroy()
{
    auto temp=head;
    while(temp)
    {
        delete head;
        temp=temp->next;
    }
}
template<class ElemType>
bool LinkList<ElemType>::InsTail( ElemType &e )
{
    auto temp=new LinkNode<ElemType>(e);
    if(!temp)return false;
    tail->next=temp;
    tail=temp;
    return true;
}
template<class ElemType>
void LinkList<ElemType>::CreateList_Tail(vector<ElemType> &A)
{
    auto xx=A.begin();
    for(; xx!=A.end(); xx++)
        InsTail(*xx);
}
template<class ElemType>
void shuru(stringstream &in,vector<ElemType> &A)
{
    ElemType str;
    while(in>>str)A.push_back(str);
}
template<class ElemType>
int LinkList<ElemType>::ListLength() const
{
    int len = 0;
    LinkNode<ElemType> *temp = head->next;
    while(temp)
    {
        len ++;
        temp = temp->next;
    }
    return len;
}
template<class ElemType>
void Merge_L_Order( LinkList<ElemType> &A, LinkList<ElemType> &B )
{
    A.ListTraverse();
    B.ListTraverse();
    cout<<endl;
    auto pa=A.GetHead()->next;
    auto tb=B.GetHead()->next;
    auto h=A.GetHead();
    while(pa && tb)
    {
        if(pa->data < tb->data)
        {
            h->next=pa;
            h=h->next;
            pa=pa->next;
        }
        else
        {
            h->next=tb;
            h=h->next;
            tb=tb->next;
        }
    }
    if(pa) h->next=pa;
    if(tb) h->next=tb;
    auto pf=A.GetHead()->next;
    auto pb=A.GetHead()->next;
    while(pb)
    {
        if(pf->data != pb->data)
        {
            pf->next=pb;
            pf=pf->next;
        }
        pb=pb->next;
    }
    pf->next=nullptr;
    A.ListTraverse();
}
int main()
{
    int kind;
    cin>>kind;
    getchar();
    if(kind!=0&&kind!=1&&kind!=2&&kind!=3)
    {
        cout<<"err"<<endl;
    }
    else if(kind==0)
    {
        string s1,s2;
        vector<int> a0,b0;
        LinkList<int> A0,B0;
        getline(cin,s1);
        stringstream inf(s1);
        getline(cin,s2);
        stringstream ins(s2);
        shuru(inf,a0);
        shuru(ins,b0);
        A0.CreateList_Tail(a0);
        B0.CreateList_Tail(b0);
        Merge_L_Order(A0,B0);
    }
    else if(kind==1)
    {
        string s1,s2;
        vector<double> a1,b1;
        LinkList<double> A1,B1;
        getline(cin,s1);
        stringstream inf(s1);
        getline(cin,s2);
        stringstream ins(s2);
        shuru(inf,a1);
        shuru(ins,b1);
        A1.CreateList_Tail(a1);
        B1.CreateList_Tail(b1);
        Merge_L_Order(A1,B1);
    }
    else if(kind==2)
    {
        string s1,s2;
        vector<char> a2,b2;
        LinkList<char> A2,B2;
        getline(cin,s1);
        stringstream inf(s1);
        getline(cin,s2);
        stringstream ins(s2);
        shuru(inf,a2);
        shuru(ins,b2);
        A2.CreateList_Tail(a2);
        B2.CreateList_Tail(b2);
        Merge_L_Order(A2,B2);
    }
    else if(kind==3)
    {
        string s1,s2;
        vector<string> a3,b3;
        LinkList<string> A3,B3;
        getline(cin,s1);
        stringstream inf(s1);
        getline(cin,s2);
        stringstream ins(s2);
        shuru(inf,a3);
        shuru(ins,b3);
        A3.CreateList_Tail(a3);
        B3.CreateList_Tail(b3);
        Merge_L_Order(A3,B3);
    }
    return 0;
}