线性表交集差

我是大笨比之线性表交集差

#include <iostream>
using namespace std;

template <class T>                    // 单链表结点类，T指定结点的元素类型
class Node
{
public:
	T data;                           // 数据域，保存数据元素
	Node<T> *next;                    // 指针域，指向后继节点

	Node()                            // 构造结点，data域未初始化
	{
		this->next = NULL;            // 指针赋值
	}

	Node(T data, Node<T> *next=NULL)  // 构造结点，data指定数据元素，next指定后继结点地址，默认空值
	{
		this->data = data;            // 执行T的=赋值运算
		this->next = next;            // 指针赋值
	}
};

template <class T>
class SinglyList
{
public:
	Node<T> *head;                    // 头指针，指向单链表的头结点

	SinglyList();                     // 构造空单链表
	SinglyList(T values[], int n);    // 构造单链表，由values数组提供元素
	~SinglyList();                    // 析构函数

	Node<T>* search(T key);
	friend ostream& operator <<<>(ostream&, SinglyList<T>&);
	T remove(int i);
	void removeAll();
	SinglyList<T>& operator-=(SinglyList<T> &List);
};

template <class T>                    // 构造空单链表
SinglyList<T>::SinglyList()
{
	this->head = new Node<T>();       // 创建头结点，data数据域未初始化
}

template <class T>
SinglyList<T>::SinglyList(T values[], int n)  // 构造单链表，由values数组提供元素
{
	this->head = new Node<T>();               // 创建头结点，构造空链表
	Node<T> *rear = this->head;               // rear指向单链表最后一个结点
	for(int i=0; i<n; i++)                    // 若 n>0，构造非空链表
	{
		rear->next = new Node<T>(values[i]);  // 创建结点链入rear结点之后，尾插入
		rear = rear->next;                    // rear指向新的链尾结点
	}
}

template <class T>
SinglyList<T>::~SinglyList()
{
	this->removeAll();
	delete this->head;
}

template <class T>
Node<T>* SinglyList<T>::search(T key)
{
	Node<T> *p = this->head->next;
	while(p!=NULL&&p->data!=key)
		p = p->next;
	if(p!=NULL)
		return p;
	else
		return NULL;
}

template <class T>
ostream& operator <<<>(ostream& out, SinglyList<T>& list)
{
	out << "list:";
	for(Node<T> *p = list.head->next; p!=NULL; p=p->next)
	{
		out << p->data;
		if(p->next!=NULL)
			out << ",";
	}
	out << endl;
	return out;
}

template <class T>
T SinglyList<T>::remove(int i)       // 删除第i个节点
{
	Node<T> *front = this->head;
	for(int j=0; front->next!=NULL&&j<i; j++)
		front = front->next;
	if(i>=0&&front->next!=NULL)
	{
		Node<T> *q = front->next;
		T old = q->data;
		front->next = q->next;
		delete q;
		return old;
	}
}

template <class T>
void SinglyList<T>::removeAll()
{
	Node<T> *p = this->head->next;  // 指向下一个链表的头结点
	Node<T> *temp = NULL;
	while(p != NULL)                // 遍历单链表
	{
		temp = p;
		p = p->next;
		delete temp;
	}
	head->next = NULL;
}

template <class T>
SinglyList<T>& SinglyList<T>::operator-=(SinglyList<T>& List)
{
	int i = 0;
	Node<T> *p = this->head;
	Node<T> *q = NULL;
	while(p!=NULL)
	{
		q = p->next;
		if(q!=NULL&&List.search(q->data)!=NULL)
		{
			p->next = q->next;
		}
		else
			p = q;
	}
	return *this;
}

int main()
{
	SinglyList<char> list1("abcde",5),list2("bcd",3);
	cout << list1;
	list1-=list2;
	cout << list1;
	return 0;
}