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

目的：使用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 );

循环链表模板类原型参考如下：

/* 循环单链表的结点定义*/

template<class ElemType>

struct LinkNode

{

  ElemType data;

       LinkNode<ElemType> *next;

       LinkNode(LinkNode<ElemType> *ptr = NULL){next = ptr;} //构造函数1，用于构造头结点

       LinkNode(const ElemType &item, LinkNode<ElemType> *ptr = NULL) //构造函数2，用于构造其他结点   

       //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

      {

           next = ptr;

           data = item;

      }

      //int getNum(){ return number; } //取得结点的序号 

      ElemType getData(){ return data; }   //取得结点的数据域的值 

      void SetLink( LinkNode<ElemType> *link ){ next = link; }  //修改结点的next域 

      void SetLink( ElemType value ){ data = value; }   //修改结点的next域

};

//带头结点的循环单链表 

template<class ElemType>

class CirLinkList{

   private:

      LinkNode<ElemType> *head;   // 头结点

      LinkNode<ElemType> *tail;   // 尾结点

   public:

      //无参数的构造函数

      CirLinkList(){head = new LinkNode<ElemType>; tail = head; head->next = head;}

      //带参数的构造函数

      CirLinkList(const ElemType &item){head = new LinkNode<ElemType>(item); tail = head; head->next = head;}

      //拷贝构造函数

      CirLinkList(CirLinkList<ElemType> &List);

      //析构函数

      ~CirLinkList(){ListDestroy();}

      //销毁链表

      void ListDestroy();

      //清空链表

      void ListClear(); 

      //返回链表的长度

      int ListLength() const;

      //判断链表是否为空表

      bool ListEmpty() const;

      //获取循环链表头结点

      LinkNode<ElemType>* GetHead() { return head;}

      //获取循环链表尾结点

      LinkNode<ElemType>* GetTail() { return tail;}

      //设置链表头结点

      void SetHead(LinkNode<ElemType> *p){ head = p;}      

      //在链表的第pos个位置之后插入e元素

      bool ListInsert_next(int pos,ElemType e);

      //在首结点之前插入一个结点

      bool InsFirst( ElemType &e );

      //在尾结点之前插入一个结点

      bool InsTail( ElemType &e );

      //表头插入法动态生成链表

     void CreateList_Head(vector<ElemType> &A);      

      //表尾插入法动态生成链表

      void CreateList_Tail(vector<ElemType> &A);     

      //遍历链表

      bool ListTraverse() const;

};

输入说明 :

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

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

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

输出说明 :

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

否则：

第一行：第一个循环链表的遍历结果

第二行：第二个循环链表的遍历结果

空行

第四行：合并后循环链表的遍历结果

输入范例 :

1
13.1 5.2 27.3 9.4 32.5 123.6 76.7 98.8 54.9 87.0
1.1 3.2 7.3 8. 11.5

输出范例 :

13.1->5.2->27.3->9.4->32.5->123.6->76.7->98.8->54.9->87
1.1->3.2->7.3->8->11.5

13.1->5.2->27.3->9.4->32.5->123.6->76.7->98.8->54.9->87->1.1->3.2->7.3->8->11.5

---

循环链表的合并挺简单的

如图所示：

 这是函数实现：

	template<class T>
	void merge(LinkList<T> &a,LinkList<T>& b){
		a.tail->next=b.head->next;
		a.tail=b.tail;
		a.tail->next=a.head;
		b.head->next=NULL;
		b.tail=b.head;
		b.tail->next=b.head;
	}

 

 

直接上题解了

#include<iostream>
#include<stdio.h>
using namespace std;

/* 单链表的结点定义 */

template<class T>
struct LinkNode{
	T data;
	LinkNode<T>* next;
	LinkNode(LinkNode<T>* ptr=NULL){
		next=ptr;
	}
	LinkNode(const T& item,LinkNode<T>* ptr=NULL){
		next=ptr;
		data=item;
	}
	void SetLink(LinkNode<T>* link){
		next=link;
	}
	void SetLink(T value){
		data=value;
	}
};

//带头结点和尾指针的循环单链表
template<class T>
class LinkList
{
private:
    LinkNode<T>* head;
    LinkNode<T>* tail;
public:
    LinkList() { head = new LinkNode<T>; tail = head; tail->next=head;}
    void CreateList_Tail(const T A)//后插法，在链表尾部插入一个节点 
    {
        LinkNode<T>* p = new LinkNode<T>(A);
        tail->next = p;
        tail = p;
        tail->next=head;
    }
	template<class Elemtype>
	friend void fun(LinkList<Elemtype>& a,LinkList<Elemtype>& b);
	template<class Elemtype>
	friend void merge(LinkList<Elemtype>& a,LinkList<Elemtype>& b);
   
};

	template<class T>
	void merge(LinkList<T> &a,LinkList<T>& b){
		a.tail->next=b.head->next;
		a.tail=b.tail;
		a.tail->next=a.head;
		b.head->next=NULL;
		b.tail=b.head;
		b.tail->next=b.head;
	}



template<class T>
void fun(LinkList<T>& a,LinkList<T>& b){
	T num;
	while(cin>>num,a.CreateList_Tail(num),getchar()!='\n');
	while(cin>>num,b.CreateList_Tail(num),getchar()==' ');
	for (LinkNode<T>* i = a.head->next; i != a.head; i = i->next)	 i->next != a.head ? (cout << i->data << "->") : (cout << i->data<<"\n");
	for (LinkNode<T>* i = b.head->next; i != b.head; i = i->next)	 i->next != b.head ? (cout << i->data << "->") : (cout << i->data<<"\n");
	cout<<endl;
	merge(a,b);
	for (LinkNode<T>* i = a.head->next; i != a.head; i = i->next)	 i->next != a.head ? (cout << i->data << "->") : (cout << i->data);
}
int main()
{
	int type;
    cin >> type;
    if (type == 0) {
        LinkList<int> a,b;
        fun(a,b);
    }
    else if (type == 1) {
        LinkList<double> a,b;
        fun(a,b);
    }
    else if (type == 2) {
        LinkList<char> a,b;
        fun(a,b);
    }
    else if (type == 3) {
        LinkList<string> a,b;
        fun(a,b);
    }
    else {
        cout << "err";
    }
    return 0;
}