单链表的实现(带头结点)

// LinkList.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
using namespace std;

template<class T>
struct Node
{
T data;  //结点的数据域
Node<T>* next; //结点的指针域，指向下一个结点
};

template<class T>
class LinkList
{
public:
LinkList();//默认构造函数
LinkList(const LinkList<T>& otherlist);//拷贝构造函数
void initList();//初始化链表
void destroyList();//销毁链表
bool isEmpty();//判断链表是否为空
void creatInsertHead();//头插法创建链表
void creatInsertRear();//尾插法创建链表
void getFirstData(T& firstdata);
int length();
void search(const T searchdata);//搜索指定的结点
void insertHead(const T newdata);//在表头插入新的结点
void insertRear(const T newdata);//在表尾插入新的结点
void insertBefore(const int pos,const T newdata);//在指定的位置前插入新的结点
void insertAfter(const int pos,const T newdata);//在指定的位置后插入新的结点
void deleteNode(const T deletedata);//删除结点
void deleteNode(const int pos,T& deletedata);//删除指定位置的结点
void reverse();//逆置链表
const LinkList<T>& operator=(const LinkList<T>& otherlist);//重载赋值运算符
friend ostream& operator<< <>(ostream& cout,const LinkList<T>& linklist);
~LinkList();

void merge1(LinkList<T>& A,LinkList<T>& B);//单链表A和B，AB增C非增，C=A+B,利用原表A和B的空间，允许有相同元素
void merge2(LinkList<T>& A,LinkList<T>& B);//单链表A和B，AB增C增，C=A+B,利用原表A和B的空间，允许有相同元素
void intersect1(LinkList<T>& A,LinkList<T>& B);//AB增C增,C=A交B,不利用原表A和B,AB中元素均无重复，但A和B中可能有相同元素,C中元素各不相同
void intersect2(LinkList<T>& A,LinkList<T>& B);//AB增C增,C=A交B,不利用原表A和B,AB中元素可能有重复元素，C中元素各不相同
void difference(LinkList<T>& A);//AB增C增,B=B-A,A中无重复,B中无重复,不能破坏A空间,但是直接在B表中修改

private:
Node<T>* head; //指向头结点
int m_length; //单链表的长度
};

template<class T>
LinkList<T>::LinkList()
{
head = new Node<T>;
head->next = NULL;
m_length = 0;
}

template<class T>
LinkList<T>::LinkList(const LinkList<T>& otherlist)
{
//首先建立头结点
head = new Node<T>;
head->next = NULL;
m_length = 0;

Node<T> *current = head; //current始终指向待建链表的最后一个结点
Node<T> *otherlistcurrent = otherlist.head->next;//指向该链表的第一个结点
while(otherlistcurrent!=NULL)
{
//建立一个新的结点
Node<T> *newnode = new Node<T>;
newnode->data = otherlistcurrent->data;
//将新结点插入表尾
newnode->next = current->next;
current->next = newnode;

current = current->next;
otherlistcurrent = otherlistcurrent->next;
m_length++;
}
}

template<class T>
void LinkList<T>::initList()//链表已经存在,所有的结点被销毁
{
destroyList();
head = new Node<T>;
head->next = NULL;
m_length = 0;
}

template<class T>
void LinkList<T>::destroyList()//销毁链表中所有的结点，包括头结点
{
Node<T> * current;
while(head!=NULL)
{
current = head;
head = current->next;
delete current;
}
head = NULL;
m_length = 0;
}

template<class T>
bool LinkList<T>::isEmpty()//判断链表是否为空
{
if (head->next == NULL)
{
return true;
}
else
{
return false;
}
}

template<class T>
void LinkList<T>::creatInsertHead()//头插法创建链表
{
Node<T> *newnode;
cout<<"请输入链表的长度：";
cin>>m_length;
cout<<"请输入要插入的元素：";
for (int i=0; i<m_length; i++)
{
newnode = new Node<T>;
cin>>newnode->data;
newnode->next = head->next;
head->next = newnode;
}
}

template<class T>
void LinkList<T>::creatInsertRear()//尾插法创建链表
{
Node<T> *newnode;
Node<T> *current =head;
cout<<"请输入链表的长度：";
cin>>m_length;
cout<<"请输入要插入的元素：";
for (int i=0; i<m_length; i++)
{
newnode = new Node<T>;
cin>>newnode->data;
newnode->next = current->next;
current->next = newnode;
current = current->next;
}
}

template<class T>
void LinkList<T>::getFirstData(T& firstdata)
{
if (!isEmpty())
{
firstdata = head->next->data;
}
else
{
cout<<"链表为空！"<<endl;
}
}

template<class T>
int LinkList<T>::length()
{
return m_length;
}

template<class T>
void LinkList<T>::search(const T searchdata)//搜索指定的结点
{
if (isEmpty())
{
cout<<"链表为空！"<<endl;
return;
}

Node<T> *current = head->next;
while(current!=NULL&¤t->data!=searchdata)
{
current = current->next;
}
if (current == NULL)
{
cout<<searchdata<<"没有被找到！"<<endl;
}
else
{
cout<<searchdata<<"被找到了！"<<endl;
}
}

template<class T>
void LinkList<T>::insertHead(const T newdata)//在表头插入新的结点
{
Node<T> *newnode = new Node<T>;
newnode->data = newdata;
newnode->next = head->next;
head->next = newnode;
m_length++;
}

template<class T>
void LinkList<T>::insertRear(const T newdata)//在表尾插入新的结点
{
Node<T> *current = head;
while(current->next!=NULL)
{
current = current->next;
}
Node<T> * newnode = new Node<T>;
newnode->data = newdata;
newnode->next = current->next;
current->next = newnode;
m_length++;
}

template<class T>
void LinkList<T>::insertBefore(const int pos,const T newdata)//在指定的位置前插入新的结点
{
int i = 1;
if (pos<1 || pos>m_length)//注意参数有效性的检查
{
cout<<"指定的位置不正确！"<<endl;
return;
}
Node<T> *newnode = new Node<T>;
newnode->data = newdata;
Node<T> *current = head;
if (pos == 1)
{
newnode->next = head->next;
head->next = newnode;
}
else
{
while(i < pos)
{
current = current->next;
i++;
}
newnode->next = current->next;
current->next =newnode;
}
m_length++;
}

template<class T>
void LinkList<T>::insertAfter(const int pos,const T newdata)//在指定的位置后插入新的结点
{
if (pos<1 || pos>m_length)
{
cout<<"指定的位置不正确！"<<endl;
return;
}
Node<T> *current = head;
Node<T> *newnode = new Node<T>;
newnode->data = newdata;
int i = 0;
while(i<pos)
{
current = current->next;
i++;
}
newnode->next = current->next;
current->next =newnode;
m_length++;
}

template<class T>
void LinkList<T>::deleteNode(const T deletedata)//删除结点
{
Node<T> *precurrent = head;
Node<T> *current = head->next;
if (isEmpty())//注意判断链表是否为空
{
cout<<"链表为空！"<<endl;
}
while(current->next!=NULL&¤t->data!=deletedata)
{
precurrent = current;
current = current->next;
}
if (current == NULL)
{
cout<<deletedata<<"不存在！"<<endl;
}
else
{
precurrent->next = current->next;
delete current;
cout<<deletedata<<"已经从表中删除！"<<endl;
m_length--;
}
}

template<class T>
void LinkList<T>::deleteNode(const int pos,T& deletedata)//删除指定位置的结点
{
if (isEmpty())
{
cout<<"链表为空！"<<endl;
}
if (pos<1 || pos>m_length)
{
cout<<"删除位置错误！"<<endl;
deletedata = -1;
return;
}
Node<T> *current = head;
int i=1;
while(i<pos)
{
current = current->next;
i++;
}
Node<T> *temp;
temp = current->next;
deletedata = temp->data;
current->next = temp->next;
delete temp;
m_length--;
}

template<class T>
void LinkList<T>::reverse()//逆置链表
{
Node<T> *current = head->next;
head->next = NULL;//注意此处的处理

if (current == NULL)
{
cout<<"链表为空"<<endl;
}

while (current!=NULL)
{
Node<T> *nextcurrent = current->next;//注意此处的处理
current->next = head->next;
head->next = current;
current = nextcurrent;
}
}

template<class T>
const LinkList<T>& LinkList<T>::operator=(const LinkList<T>& otherlist)//重载赋值运算符
{
Node<T> *current = head;
Node<T> *otherlistcurrent = otherlist.head->next;
if (this != &otherlist)//自赋值检查
{
if (!(this->isEmpty()))
{
this->initList();
}
while (otherlistcurrent!=NULL)
{
Node<T> *newnode = Node<T>;
newnode = otherlistcurrent->data;

newnode->next = current->next;
current->next = newnode;
current = current->next;
otherlistcurrent = otherlistcurrent->next;
m_length++;
}
}
return *this;
}

template<class T>
ostream& operator<< <>(ostream& cout,const LinkList<T>& linklist)
{
Node<T> *current = linklist.head->next;
if (current!=NULL)
{
while(current!=NULL)
{
cout<<current->data<<" ";
current = current->next;
}
}
else
{
cout<<"链表为空"<<endl;
}
return cout;
}

template<class T>
void LinkList<T>::merge1(LinkList<T>& A,LinkList<T>& B)//单链表A和B，AB增C非增，C=A+B,利用原表A和B的空间，允许有相同元素
{
Node<T> *currentA = A.head->next;
Node<T> *currentB = B.head->next;
m_length = A.m_length + B.m_length;
//处理C的头结点，利用A的头结点
this->head = A.head;
this->head->next = NULL;
delete B.head;
Node<T> *temp;
while(currentA!=NULL && currentB!=NULL)
{
if (currentA->data > currentB->data)
{
temp = currentB;
currentB = currentB->next;
temp->next = this->head->next;
this->head->next = temp;
}
else
{
temp = currentA;
currentA = currentA->next;
temp->next = this->head->next;
this->head->next = temp;
}
}

while(currentA!=NULL)
{
temp = currentA;
currentA = currentA->next;
temp->next = head->next;
head->next = temp;
}
while(currentB!=NULL)
{
temp = currentB;
currentB = currentB->next;
temp->next = head->next;
head->next = temp;
}
}

template<class T>
void LinkList<T>::merge2(LinkList<T>& A,LinkList<T>& B)//单链表A和B，AB增C增，C=A+B,利用原表A和B的空间，允许有相同元素
{
Node<T> *currentA = A.head->next;
Node<T> *currentB = B.head->next;
m_length = A.m_length + B.m_length;
//处理C的头结点，利用A的头结点
this->head = A.head;
this->head->next = NULL;
delete B.head;
Node<T> *currentC = A.head;
while(currentA!=NULL && currentB!=NULL)
{
if (currentA->data > currentB->data)
{
currentC->next = currentB;
currentB = currentB->next;
currentC = currentC->next;
}
else
{
currentC->next = currentA;
currentA = currentA->next;
currentC = currentC->next;
}
}

if(currentA!=NULL)
{
currentC->next = currentA;
}
if(currentB!=NULL)
{
currentC->next = currentB;
}
}

template<class T>
void LinkList<T>::intersect1(LinkList<T>& A,LinkList<T>& B)//AB增C增,C=A交B,不利用原表A和B,AB中元素均无重复，但A和B中可能有相同元素,C中元素各不相同
{
Node<T> *currentA = A.head->next;
Node<T> *currentB = B.head->next;
head = new Node<T>;
head->next = NULL;
Node<T> *currentC = head;
while(currentA!=NULL && currentB!=NULL)
{
if (currentA->data < currentB->data)
{
currentA = currentA->next;
}
else if (currentA->data > currentB->data)
{
currentB = currentB->next;
}
else
{
Node<T> *newnode = new Node<T>;
newnode->data = currentA->data;
currentC->next = newnode;
currentC = currentC->next;
currentA = currentA->next;
currentB = currentB->next;
m_length++;
}
}
currentC->next = NULL;
}

template<class T>
void LinkList<T>::intersect2(LinkList<T>& A,LinkList<T>& B)//AB增C增,C=A交B,不利用原表A和B,AB中元素可能有重复元素，C中元素各不相同
{
bool isfirst = true;//标志位，表示第一次插入
Node<T> *currentA = A.head->next;
Node<T> *currentB = B.head->next;
head = new Node<T>;
head->next = NULL;
Node<T> *currentC = head;
while(currentA!=NULL && currentB!=NULL)
{
if (currentA->data < currentB->data)
{
currentA = currentA->next;
}
else if (currentA->data > currentB->data)
{
currentB = currentB->next;
}
else
{
if (isfirst)
{
Node<T> *newnode = new Node<T>;
newnode->data = currentA->data;
currentC->next = newnode;
currentC = currentC->next;
isfirst = false;
}
else
{
if (currentC->data!=currentA->data)
{
Node<T> *newnode = new Node<T>;
newnode->data = currentA->data;
currentC->next = newnode;
currentC = currentC->next;
}
}
currentA = currentA->next;
currentB = currentB->next;
m_length++;
}
}
currentC->next = NULL;
}

template<class T>
void LinkList<T>::difference(LinkList<T>& A)//AB增C增,B=B-A,A中无重复,B中无重复,不能破坏A空间,但是直接在B表中修改
{
Node<T> *currentA = A.head->next;
Node<T> *precurrentB = head;
Node<T> *currentB = head->next;
while(currentA!=NULL && currentB!=NULL)
{
if (currentA->data > currentB->data)
{
precurrentB = currentB;
currentB = currentB->next;
}
else if (currentA->data < currentB->data)
{
currentA = currentA->next;
}
else
{
currentA = currentA->next;
precurrentB->next = currentB->next;
delete currentB;
currentB = precurrentB->next;
m_length--;
}
}
if (currentB == NULL)
{
precurrentB->next = NULL;
}
}

template<class T>
LinkList<T>::~LinkList()
{
destroyList();
}

int _tmain(int argc, _TCHAR* argv[])
{
LinkList<int> *list1 = new LinkList<int>;
list1->creatInsertRear();
cout<<"尾插法创建的链表为：";
cout<<"list1:"<<*list1<<endl;

LinkList<int> *list2 = new LinkList<int>;
list2->creatInsertRear();
cout<<"尾插法创建的链表为：";
cout<<"list2:"<<*list2<<endl;

LinkList<int> *list3 = new LinkList<int>;
/*list3->merge1(*list1,*list2);
cout<<"list3:"<<*list3<<endl;	*/
/*list3->merge2(*list1,*list2);
cout<<"list3:"<<*list3<<endl;*/
/*list3->intersect1(*list1,*list2);
cout<<"list3:"<<*list3<<endl;*/
list3->intersect2(*list1,*list2);
cout<<"list3:"<<*list3<<endl;
list3->difference(*list1);
cout<<"list3:"<<*list3<<endl;

/*list2 = list1;
cout<<"list2:"<<*list2<<endl;*/

/*list->insertHead(9);
list->insertRear(23);
list->insertBefore(4,100);
list->insertAfter(4,200);
list->deleteNode(5);
int deletedata;
list->deleteNode(3,deletedata);
cout<<"插入删除几个元素后的链表为：";
cout<<*list<<endl;
cout<<"被删除的元素是："<<deletedata<<endl;
list->reverse();
cout<<"链表被倒置后为：";
cout<<*list<<endl;
list->initList();*/
system("pause");
return 0;
}