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

// 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 test(int argc, char* 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; 
}