线性表--使用链表实现

#include <iostream>
#include <ctime>
#include <cstdlib>
#define MaxSize 10


using namespace std;
template <typename T>
struct LinkList
{
    T data;
    LinkList<T>* next;
};
template <typename T>
class LinkListClass
{
    public:
    LinkList<T> * head;
    public:
        LinkListClass();
        ~LinkListClass();
        void CreateListF(T a[],int n);//用头插法建立单链表
        void CreateListR(T a[],int n);//尾插法创建单链表
        void DispList();//输出单链表
        int ListLength();//单链表的长度
        bool GetElem(int i,T& e);//求单链表中某个元素的值
        int LocateElem(T e);//按元素查找
        bool ListInsert(int i,T& e);//插入数据元素
        bool ListDelete(int i);//删除数据元素
        void Sort();//将单链表递增排序
        /*
        有一个单链表对象L，设计一个算法查找最后一个值为x的
        结点的逻辑序号，并分析算法的时间复杂度和空间复杂度。
        思路：
        用p遍历单链表L，用i记录结点的序号，当p->data为x，置
        j=i;最后返回j值。
        */

        /*
        有一个单链表对象L，设计一个算法逆置，分析空间复杂度和
        时间复杂度。
        用p遍历单链表L的数据结点，先将其head的next置为NULL，然后将
        p结点采用头插法插入到head结点之后。
        */
        template <typename TT>
        friend void Reverse(LinkListClass<TT>& L);
//        有两个递增有序单链表对象L1和L2，设计一个算法，采用二路归并方法
//        将L1和L2的所有结点归并到递增有序单链表对象L3中，求算法的时间复杂度
//        和空间复杂度。
        template <typename TT>
        friend void Merge2(LinkListClass<TT>& L1,LinkListClass<TT>& L2,LinkListClass<TT>&T3);
};
template <typename TT>
void Merge2(LinkListClass<TT>& L1,LinkListClass<TT>&L2,LinkListClass<TT>& L3)
{
      LinkList<TT>* p,*q,*r,*p1,*q1;
      p=L1.head->next;q=L2.head->next;
      r = L3.head;
      while(p!=NULL &&NULL!=q)
      {
          if(p->data < q->data)
          {
              p1 = p->next;
              r->next = p;
              r = p;
              p = p1;
          }
          else{
            q1 = q->next;
            r->next = q;
            r = q;
            q = q1;
          }
      }
      if(p!=NULL)
      {
          r->next = p;
      }
      if(q != NULL)
      {
          r->next = q;
      }
}

template <typename TT>
void Reverse(LinkListClass<TT>& L)
{
    LinkList<TT>* p,*q;
    p=L.head->next ;
    L.head->next =NULL;
    while(p!=NULL)
    {
        q = p->next;
        p->next = L.head->next;
        L.head->next = p;
        p = q;
    }

}
template <typename T>
int LinkListClass<T>::ListLength()
{
    LinkList<T>* p;
    p=head->next;
    int length=0;
    while(p!=NULL)
    {
        length++;
        p=p->next;
    }
    return length;
}
template <typename T>
int LinkListClass<T>::LocateElem(T e)
{
    /*
    LinkList<T>* p;p = head;
    int j = 0;//记录位置
    while(p!=NULL)
    {
        j++;
        p = p->next;
        if(e == p->data)
        {
            return j;
        }
    }
    if(NULL == p) return 0;//找不到对应的结点，返回0；
    */
    int j=1;LinkList<T>* p;
    p= head->next;
    while(p!=NULL&& p->data != e)//找不到e的值时，快速向前移动
    {
        j++;
        p= p->next;
    }
    if(p == NULL) return 0;//链表到结尾时，仍旧找不到返回0；
    else return j;
}
template <typename T>
void LinkListClass<T>::Sort()
{
    LinkList<T> * p,*q;//使用了冒泡排序法
    for(p=head->next;p->next!=NULL;p=p->next)
        for(q=p->next;q!=NULL;q=q->next)
        {
            if(p->data > q->data)
            {
                T temp;
                temp = p->data;
                p->data = q->data;
                q->data = temp;
            }
        }
//    while(p!=NULL)

}
template <typename T>
bool LinkListClass<T>::ListInsert(int i,T&e)
{
    LinkList<T>* p,*s;
    int j=0;
    p=head;
    if(i<=0) return false;
    while(j<i-1 && p!=NULL)//找到要插入数据的前一个结点
    {
        p=p->next;
        j++;
    }
    if(NULL == p) return false;//注意p==NULL的情况
    else
    {
        s=new LinkList<T>();
        s->data=e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

template <typename T>
bool LinkListClass<T>::GetElem(int i, T& e)
{
    LinkList<T>* p;
    int j = 0;
    p=head;
    if(i<=0) return false;//第i个元素
    while(j<i&&p!=NULL)
    {
        p=p->next;
        j++;
    }
    //if(j==i) e = p->data;//找到第i个元素
    if(p==NULL) return false;
    else e=p->data;//找到了第i个元素
    return true;
}
template <typename T>
bool LinkListClass<T>::ListDelete(int i)
{
    LinkList<T>* p,*s;
    int j=0;p=head;
    if(i<=0) return false;
    while(j<i-1&&p!=NULL)
    {
        p=p->next;
        j++;
    }
    if(NULL == p) return false;
    if(j==(i-1))
    {
        s=p->next;
        p->next = p->next->next;
        delete s;
        return true;
    }
}
template <typename T>
void LinkListClass<T>::CreateListR(T a[],int n)
{
    LinkList<T>* r,*s;
    r = head;
    for(int i =0 ;i<n;i++)
    {
        s = new LinkList<T>();
        s->next = NULL;
        s->data = a[i];
        r->next = s;
        r = s;

    }
}

template <typename T>
void LinkListClass<T>::DispList()
{
    LinkList<T> *p;
    p=head->next;
    while(p!=NULL)
    {
        cout<<p->data<<' ';
        p=p->next;
    }
    cout<<endl;

}
template <typename T >
LinkListClass<T>::LinkListClass()
{
    head = new LinkList<T>();
    head->next=NULL;
}
template <typename T>
LinkListClass<T>::~LinkListClass()
{
    /*
    LinkList<T>* p,*pre;
    p = head->next;
    while(p !=NULL)
    {
        pre = p;
        p=p->next;
        delete pre;
    }
    delete head;//最后head节点没有删除，最后删除。
    */


    LinkList<T>* p,*pre;
    pre = head;p= pre->next;
    while(p!=NULL)
    {
        delete pre;//释放前一个节点
        pre = p;p=p->next;//pre,p同步后移
    }
    delete pre;//当p=NULL 时，pre指向尾节点，且需释放尾节点
}


template <typename T>
void LinkListClass<T>::CreateListF(T a[],int n)
{

    cout<<"CreateListF"<<endl;
    LinkList<T>* s;
    int i;
    for(i=0;i<n;i++)
    {
        s = new LinkList<T>();
        s->next = NULL;
        s->data = a[i];
//        head->data=a[i];
//        s->next = head;
//        head = s;
        s->next = head->next;
        head->next = s;
    }
    //头插法：s->next = head->next;head->next = s;
}

double random(double start,double end)
{
    return start+(end-start)*rand()/(RAND_MAX+1.0);
}
int main()
{
    cout<<"hello world!"<<endl;

    double random(double,double);
   // double time(unsigned)
    srand(unsigned(time(0)));
    int a[MaxSize],b[MaxSize];
    for(int i=0;i<MaxSize;i++)
    {
        a[i]=int(random(0,10));
        b[i]=int(random(5,100));
    }

//    for(int i=0;i<MaxSize;i++)
//    cout<<a[i]<<' ';
//    cout<<endl;

    LinkListClass<int> linklistobj;
//    cout<<"CreateListF"<<endl;
//    linklistobj.CreateListF(a,10);
//    linklistobj.DispList();
    LinkListClass<int> L1,L2,L3;
    L1.CreateListR(a,4);
    cout<<"L1.DispList() = "<<endl;
    L1.Sort();
    L1.DispList();
    L2.CreateListF(b,6);
    cout<<"L2.DispList()"<<endl;
    L2.Sort();
    L2.DispList();
    Merge2(L1,L2,L3);
    L3.DispList();

//    cout<<"CreateListR"<<endl;
//    linklistobj.CreateListR(a,10);
//    linklistobj.DispList();
//
//    int temp;
////    linklistobj.GetElem(3,temp);
////    cout<<endl<<"temp ="<<temp<<endl;
//    linklistobj.ListDelete(3);
//    cout<<"ListDelete(3)"<<endl;
//    linklistobj.DispList();
//    cout<<"ListInsert"<<endl;
//    temp = 100;
//    linklistobj.ListInsert(9,temp);
//    linklistobj.DispList();
//    linklistobj.Sort();
//    linklistobj.DispList();
//    cout<<"Reverse:"<<endl;
//    Reverse(linklistobj);
//    linklistobj.DispList();
    return 0;
}