单链表（合并单链表）

        链式结构由于每个结点只有一个指向直接后继的指针域，因此当访问过一个结点后，只能接着访问它的后继结点，而无法访问它的前驱结点，这样的单项链表称为单向链表。 

 单链表遍历：

        单链表遍历是从单链表头指针head开始访问，沿着next指针所指示的方向依次访问每一个结点，且每个结点只能访问依次，直到最后一个结点为止。遍历时注意，不要改变head指针的指向。因此一般设置另外的一个指针变量如p,p从head开始依次访问一个结点，直到链表结束，此时p = NULL，完成依次遍历

单链表插入：

       插入结点是将值为x的新结点插入到单链表的第i个结点位置上，在插入时，需要先找到第i-1个结点，再在其后插入新结点。假设要在单链表的俩个数据域为A何B的结点之间插入一个数据域为X的结点，已知p指向数据域为A的结点，q指向数据域为x的结点，为了插入结点*q，需要修改结点*p中的指针域，使其指向结点*q，而结点*q的指针域应该指向数据域为B的结点。

 

单链表删除操作：

       单链表的删除操作是将单链表的第i个结点删除。先在单链表中找到第i-1个结点，再删除其后的结点。若要删除结点B，仅需要修改结点A的指针域。假设p是指向结点A的指针，只需要将*p结点的指针域（p->next）指向原来*p结点的下一个结点（p->next）的下一个结点P->next = p->next- >next;或者
q= q->next;
p->next =q ->next;
delete q;

template <class T>  //单链表结点类

 class SingleNode

{

    public:

        T date;    //数据域

    SingleNode<T> *next;   //指针域

SingleNode ()   //构造控结点

      {

        this ->next = NULL;  //data域未初始化

      }

        SingleNode(T data, SingleNode<T> *next = NULL)  //构造数据结点

     {

       this->data = data;

       this->next = next;

 }

};

#include<iostream.h>

#include"SingleNode.h"

template<class T>

class SingleLinkedList

{

   public:

     SingleNode<T> *head;  // 单链表头结点

    SingleLinkedList();  //构造空单链表

    SingleLinkedList(T value [],int n);  //构造由指定数组提供元素的单链表

    ~SingleLinked();  //析构

    bool isEmpty();   //判断单链表是否为空

    int GetLength ();  //求单链表长度

    SingleLinkedList <T> *GetNode (int i);  //求第i个结点指针

    T GetElem (int i);  //求第i个节点的元素

    bool SetElem ( int i, T x);  //设置第i个结点的元素

    friend ostream&operator << (ostream& out,SingleLinkedList<T>&List);  //友元输出单链表所有元素

    SingleNode<T> *InsertElem (int i, T x);  //  插入x作为第i个结点，返回新插入结点指针

    bool RemoveElem (int i, T& Old);   // 删除第i个结点，被删除元素存放在Old变量中

   void ClearList ();  //清空单链表

   };

template<class T>

SingleLinkedList <T>::SingleLinkedList()

{

this->head = NULL;

}

template <class T>

SinglekedList<T>::SinglekedList(T value[],int n)

{

   head = NULL;

   if(n>0)

   {

     head =h new SingleNode<T>(value[0]);

     SinglekedNode<T> *read = head;//指向单链表最后一个元素

 int i=1;

 while(i<n)

 {

    read->next = new SingleNode<T>(value[i++]);

read=read->next

 }

   }

}

template <class T>

SingleLinked<T>::~SingLinkedList()

{

    ClearList();

}

template<class T>

bool SingLinkedList<T>::isEmpty()

{

  return head==NULL;

}

template<class T>

int SingleLinkedList<T>::GetLength()   //单链表遍历

{

   int i=0;

   SingleNode<T> *p=head;

   while(p!=NULL)

   {

     i++;

 p=p->next;

   }

   return i;

}

template<class T>

SingleNode<T>*SingleLinkedList<T>::GetNode(int i)  //求第i个结点指针

{

   if(i<0)

   return NULL;

   int j=0;

   SingleNode<T> *p=head;

   while(p!=NULL&&j<i)

   {

     j++;

 p=p->next;

   }

   return p;

}

template<class T>

T SingleLinkedList<T>::GetElem(int i)

{

   SingleNode<T> *p = GetNode(i);

   if(p!=NULL)

   return p->data;

   throw "单链表空或参数i指定元素序号无效";

}

template <class T>

bool SingleLinkedList<T>::SetElem(int i, T x)//设置第i个结点元素为x

{

SingleNode<T>*p = GetNode(i);

if(p!=NULL)

{

  p->data = x;

  return true;

}

else

return false;

   

}

template<class T>

ostream &operator<<(ostream &out, SingleLinkedList<T>&List)

{

    SingleNode<T> *p = List.head;

    out <<"(";

while(p != NULL)

{

  out <<p->data;

   p = p->next;

   if(p!= NULL)

       out<<" ,";

 }

  out<<")\n";

return out;

}

template<class T>

void SingleLinkedList<T>::ClearList()

{

   SingleNode<T> *p=head;

   while(p!=NULL)

   {

     SingleNode<T> *q=p;

     p=p->next;

     delete q;

 }

    head = NULL;

}

template <class T>

SingleNode<T> *SingleLinkedList<T>::InsertElem(int i,T x)  //单链表插入操作

{

   SingleNode<T> *q=NULL;

   if(head == NULL || i< 0)  //头插入

     {

     q = new SingleNode<T>(x, head);  

     head = q;

    }

  else  //单链表不空且i>=1

{

   int j = 0;

   SingleNode<T> *p = head;  //寻找插入位置

   while(p ->next!=NULL&&j<i-1)

{

   j++;

   p = p-> next;

}  // 循环停止时，p指向第i-1个结点或链表最后一个结点

q= new SingleNode<T>(x,p->next);  //插入x作为p结点的后继结点

p->next =q;

}

return q;

}

template<class T>

bool SingleLinkedList<T>::RemoveElem (int i,T& Old)  //删除第i个结点，被删除元素存放在Old变量中

{

   if(head!=NULL && i>=0)

    if(i == 0)   //头删除

{

   SingleNode<T> *q =head;

   Old = q->head;

   head = head ->next;

   delete q;    // 释放结点占用的存储单元

   return true;

}

  else    // 中间/尾删除

  {

    SingleNode<T> *p =GetNode(i-1);   //p指向待删除结点的前驱结点

   if(p!=NULL && p->next!=NULL)

   {

       SingleNode<T> *q=p->next;  // q结点为p结点的后继结点

       Old = q->data;

       p->next =q->next;  //删除p的后继结点q

       delete q;

       return true;

   }

   }

   return false;

}

#define _CRT_SECURE_NO_WARNINGS

#include"SingleLinkedList.h"

void ConcatList(SingleLinkedList<char>&Lista, SingleLinkedList<char>&Listb)

{

   if(Lista.head==NULL)

   Lista.head = Listb.head;

   elae

   {

      SingleNode<char> *p=Lista.head;

  while(p->next!=NULL)

  p=p->next;

  p->next=Listb.head;

   }

   Listb.head=NULL;

}

void main()

{

   SingleLinkedList<char>Lista("abc",3);

   SingleLinkedList<char>Listb("xy",2);

   cout<<"Lista:"<<Lista<<"\n";

   cout<<"Listb:"<<Listb<<"\n";

   ConcatList(Lista,Listb);

   cout<<"Lista+Listb:"<<Lista<<"\n";

}