数据结构线性表（C++ ）

·顺序表

动态分配空间为数组的表，优点是查找快，缺点是增删麻烦

#ifndef SeqList_h
#define SeqList_h
#include<iostream>
using namespace std;
template<class T>
class SeqList{
   
protected:
    T*data;
    int maxSize,last;
    void reSize(int newSize);
public:
    SeqList(int sz);
    SeqList(SeqList<T>&L);
    ~SeqList(){
   delete[] data;}
    int Size()const{
   return maxSize;}//测表空间大小
    int Length()const{
   return last;}//测表长
    int Search(T&x)const;//查找数据
    int Locate(int i)const;//定位数据
    bool getData(int i,T&x)const//获得指定位置的数据
    {
   if(i>0&&i<=last+1)
        {
   x=data[i-1];
        return true;}
    else
        return false;}
    void setData(int i,T&x)//在指定位置放数据
    {
   
        if(i>0&&i<=last)
            {
   data[i-1]=x;}
    }
    bool Insert(int i,T&x);
    bool Remove(int i,T&x);
    bool IsEmpty()//判断空表
        {
   return(last==1)?true:false;}
    bool IsFull()//判断满表
        {
   return(last==maxSize)?true:false;}
    void Sort();//从小到大排序表
    void input(int num);//输入表
    void output();//输出表
    SeqList<T> operator=(SeqList<T>&L);
};
template <class T>
SeqList<T>::SeqList(int sz)
{
   
    if(sz>0)
    {
   
        maxSize=sz+30;last=sz;
        data=new T[maxSize];
        T x;
        if(data==NULL)
        {
   
            cout<<"存储分配错误！"<<endl;exit(1);
        }
        for(int i=0;i<sz;i++)
        {
   
            cin>>x;
            data[i]=x;
        }
    }
    else
    {
   
        cout<<"错误，请输入一个大于0的整数!";
    }
}
template <class T>
void *amalgamate(SeqList<T> L1,SeqList<T> L2);
template <class T>
SeqList<T>::SeqList(SeqList<T>&L)
{
   
    maxSize=L.Size();last=L.Length()-1;
    T value;
    data=new T[maxSize];
    if(data==NULL)
    {
   
        cout<<"存储分配错误！"<<endl;exit(1);
    }
    for(int i=1;i<=last+1;i++)
    {
   
        L.getData(i, value);data[i-1]=value;
    }
}
template<class T>
void SeqList<T>::reSize(int newSize)
{
   
    if(newSize<=0)
    {
   
        cout<<"无效的数组大小"<<endl;return;
    }
    if(newSize!=maxSize)
    {
   
        T *data_new;
        data_new=new T[newSize];
        for(int i=0;i<last;i++)
        {
   
            data_new[i]=data[i];
        }//把原数据保存
        delete []data;
        data=data_new;
        maxSize=newSize;
    }
    else
    {
   
        cout<<"无意义的操作！新开辟数组的空间与原空间大小相同，请重新确认需要开辟的空间大小";
    }
}
template <class T>
int SeqList<T>::Search(T&x)const
{
   
    int i;
    for(i=0;i<=last;i++)
    {
   
        if(data[i]==x)
        {
   
            break;
        }
    }
    if((i==last)&&(data[i]!=x))
    {
   
        cout<<"表中不存在该数据！"<<endl;
        return -1;
    }
    else
        return i+1;
}
template <class T>
int SeqList<T>::Locate(int i)const
{
   
    if(i>=1&&i<=last+1)return i;
    else return 0;
}
template <class T>
bool SeqList<T>::Insert(int i, T &x)
{
   
    if(last>=maxSize-1)
    {
   
        reSize(last+10);
    }//对书上进行改进，表满了开一个空间更大的新表即可，不必返回false
    if(i<0||i>last+1)
    {
      cout<<"插入地点不存在！";
        return false;}
    if(i==last)
        data[last]=x;
    else
    {
      for(int j=last;j>=i;j--)
        {
   
            data[j]=data[j-1];
        }
        data[i-1]=x;
    }
    last++;
    return true;
}
template <class T>
bool SeqList<T>::Remove(int i, T &x)
{
   
    if((i<0)||(i>last+1))
        return false;
    for(int j=i-1;j<last;j++)
    {
   
        data[j]=data[j+1];
    }
    last--;
    return true;
}
template<class T>
void SeqList<T>:: Sort()
{
   
    T temp;
    for(int i=0;i<last;i++)
    {
   
        for(int j=i;j<last;j++)
        if(data[j]>data[j+1])
        {
   
            temp=data[j];
            data[j]=data[j+1];
            data[j+1]=temp;
        }
    }
}//冒泡排序
template <class T>
void SeqList<T>::input(int num)
{
   
    for(int i=0;i<num;i++)
    {
   
        cin>>data[i];
        last++;
    }
}
template <class T>
void SeqList<T>::output()
{
   
    for(int i=0;i<last;i++)
    {
   
        cout<<data[i]<<" ";
    }
    cout<<endl;
}
template<class T>
void amalgamate(SeqList<T> &L1,SeqList<T> &L2);
void amalgamate(SeqList<int> &L1,SeqList<int> &L2)
{
   
    int sum=0,count_am=0,count_l2=0;//sum为合并两表后一共有多少数据，count为记录目前处理了多少数据
    sum=L1.last+L2.last;
    if(L2.data==NULL)
        exit(1);
    int *p;
    p=new int[sum];
    for(;count_am<L1.last;count_am++)
    {
   
        p[count_am]=L1.data[count_am];
    }
    for(;count_am<sum;count_am++)
    {
   
        p[count_am]=L2.data[count_l2];
        count_l2++;
    }
    delete []L1.data;
    L1.data=p;
    L1.maxSize=sum;
    L1.last=sum;

}
template<class T>
void SeqList<T>::delete_dbl()
{
   
    for(int i=0;i<last;i++)
    {
   
        for(int j=1;j<last;j++)
        {
   
            if((data[i]==data[j])&&(i!=j))//需要保证i!=j
            {
   
                Remove(j+1, data[j]);
                j--;
            }

        }
        output();
    }
}

·单链表

#ifndef List_h
#define List_h
#include <iostream>//此单链表头结点为空
using namespace std;
template <class T>
struct LinkNode{
   
    T data;
    LinkNode<T> *link;
    LinkNode(LinkNode<T> *ptr=NULL){
   link=ptr;}//仅初始化指针成员的构造函数
    LinkNode(const T&item,LinkNode<T> *ptr=NULL)//初始化数据与指针成员的构造函数
    {
      data=item;link=ptr;}
};
template <class T>
class List{
   
public:
    List(const T&x);//构造函数
    List(List<T>&L);//复制构造函数
    ~List(){
   makeEmpty();}
    void makeEmpty();//置空
    int Length();//计算链表长度
    LinkNode<T> *getHead(){
   return first;}//返回头结点地址
    LinkNode<T> *Search(T x);//查找
    LinkNode<T> *Locate(int i);//搜索第i个元素地址
    bool getData(int i,T &x);//取出第i个元素的地址
    void setData(int i,T &x);//用x修改第i个元素的值
    bool Insert(int i,T &x);//在第i个元素后插入x
    bool Remove(int i);//删除第i个元素，x返回该元素的值
    bool IsEmpty(){
   return first->link==NULL?true:false;}//判断表空否，空返回true
    bool IsFull();//判断空间满没 还能不能new
    void inputFront();//输入，按前插法建链表
    void inputRear();//输入，按后插法建链表
    void output();//输出
    List<T>& operator=(List<T>&L);//重载赋值操作
protected:
    LinkNode<T> *first;
    int count=0;
};
template<class T>
List<T>::List(const T&x)
{
   
    T data_new;
    LinkNode<T> *p,*pr;
    for(int i=0;i<x;i++)
    {
   
        cin>>data_new;
        if(count==0)
        {
   
            first=new LinkNode<T>;
            if(first==NULL)
            {
   
                cout<<"错误！头结点建立失败！";
                exit(1);
            }
            first->data=data_new;
            first->link=NULL;
            pr=first;
            count++;
        }
        else
        {
   
            p=new LinkNode<T>;
            if(p==NULL)
            {
   
                cout<<"错误，第"<<count+1<<"个结点建立失败！";
                exit(1);
            }
            p->data=data_new;
            pr->link=p;
            pr=p;
            pr->link=NULL;
            count++;
        }
    }
}
template<class T>
void List<T>::makeEmpty()//置空
{
   
    LinkNode