线性表——顺序表与单链表（模板）

顺序表（线性表的顺序存储结构，静态存储分配，通常用一位数组来实现）

#include <iostream>
using namespace std;
const int MaxSize=100;
template <typename T>
class SeqList
{
  private:
    int length;
    T data[MaxSize];
  public :
    SeqList();
    SeqList(T a[],int n);
    ~SeqList();
    int Length();
    T Get(int i);//按位查找
    int Locate(T x);//按值查找
    T Delete(int i);
    int Empty();
    void Insert(int i,T x);
    void Print();
};
template <typename T>
   SeqList<T>::SeqList()
   {
       length=0;//空表长度为0
   }
template <typename T>
    SeqList<T>::SeqList(T a[],int n)
    {
        if(n>MaxSize)throw"上溢";
        for(int i=0;i<n;i++)
        {
          data[i]=a[i];
        }
        length=n;
    }
template <typename T>
    SeqList<T>::~SeqList()
    {}
template <typename T>
    int SeqList<T>::Empty()
    {
        if(length==0)
            return 1;
        else
            return 0;
    }
template <typename T>
int SeqList<T>::Length()
{
    return length;
}
template <typename T>
T SeqList<T>::Get(int i)
{
    if(i>length||i<1)throw"位置有误";
    else
        return data[i-1];
//存放数据的一维数组下标（数组下标从0开始）比表示顺序表元素的下标（顺序表元素下标从1开始）数值上少1
}
template <typename T>
int SeqList<T>::Locate(T x)
{for(int i=0;i<length;i++)
    if(data[i]==x)
        return i+1;//找到则返回顺序表元素下标
    return 0;//没找到返回0
}
template <typename T>
void SeqList<T>::Insert(int i,T x)
{
    if(i<1||i>length+1) throw"插入位置有误";
    if(length==MaxSize)throw"上溢";//表示已满，不能再插入
    for(int j=length;j>=i;j--)
    {//到后往前寻找插入位置，后移
        data[j]=data[j-1];
    }
    data[i-1]=x;
    length++;

}
template <typename T>
void SeqList<T>::Print()
{
    for(int i=0;i<length;i++)
    {
        cout<<data[i]<<" ";
    }
}
template <typename T>
T SeqList<T>::Delete(int i)
{
    if(i<1||i>length)throw"删除位置有误";
    if(length==0)throw"下溢";
    int x=data[i-1];
    for(int j=i;j<length;j++)
    {
        data[j-1]=data[j];
    }
    length--;
    return x;
}
int main()
{
    int r[]={1,2,3,4,5};
    SeqList<int>L(r,5);
    cout<<"输出原始顺序表：";
    L.Print();
    cout<<endl;
    cout<<"插入操作：";
    try
    {
        L.Insert(2,8);
        L.Print();
    }catch(char *str)
    {
        cout<<str<<"操作有误！";
    }
    cout<<endl;
    cout<<"删除操作";
    try
    {
        L.Delete(2);
        L.Print();
    }catch(char *str)
    {
        cout<<str<<"操作有误！";
    }
    cout<<endl;
    cout<<"按位查找操作";
    try
    {
        cout<<L.Get(4)<<endl;
    }catch(char *str)
    {
        cout<<str<<"操作有误！";
    }
    cout<<"按值查找操作";
    try
    {
        cout<<L.Locate(4)<<endl;
    }catch(char *str)
    {
        cout<<str<<"操作有误！";
    }
    return 0;
}

单链表（线性表的链式存储结构，动态存储分配空间，指针实现）

#include <iostream>
//单链表
using namespace std;
template<typename DataType>
struct Node
{
    Node<DataType>*next;
    DataType data;
};

template<typename DataType>
class LinkList
{
    public:
        LinkList();
        LinkList(DataType a[],int n);
        ~LinkList();
        int length();
        int empty();
        DataType get(int i);//按位查找
        int locate(DataType x);//按值查找
        void insert(int i,DataType x);
        DataType delete1(int i);
        void print();
    private:
        Node<DataType>*first;
};
template<typename DataType>
LinkList<DataType>::LinkList()
{//初始化
    first=new Node<DataType>;//生成头结点
    first->next=NULL;//头结点的指针域置空
}

template<typename DataType>
int LinkList<DataType>::empty()
{//判断是否为空，判断是否只有头结点，即判断first->next是否为空
    if(first->next=NULL)return 1;
    else return 0;
}
template<typename DataType>
void LinkList<DataType>::print()
{//遍历，设置一个工作节点p，依次指向各个结点
    Node<DataType>*p=first->next;//工作指针初始化
    while(p!=NULL)
    {
        cout<<p->data<<" ";
        p=p->next;//工作指针初始化
    }
    cout<<endl;
}
template<typename DataType>
int LinkList<DataType>::length()
{//采用遍历的方式来求其长度
    Node<DataType>*p=first->next;//工作指针初始化
    int count=0;//计数
    while(p!=NULL)
    {
        p=p->next;//工作指针初始化
        count++;
    }
    return count;
}
template<typename DataType>
DataType LinkList<DataType>::get(int i)
{//工作指针p扫描链表，找第i个结点
    Node<DataType>*p=first->next;//工作指针初始化
    int count=1;
    while(p!=NULL&&count<i)
    {
        p=p->next;//工作指针指向下一个
        count++;
    }
    if(p==NULL)throw"查找位置错误";
    else return p->data;
}
template<typename DataType>
int LinkList<DataType>::locate(DataType x)
{
    Node<DataType>*p=first->next;
    int count=1;
    while(p!=NULL)
    {
        if(p->data==x)return count;
        p=p->next;
        count++;
    }
    return 0;//退出循环，查找失败
}

template<typename DataType>
void LinkList<DataType>::insert(int i,DataType x)
{
    Node<DataType>*p=first,*s=NULL;//s为插入的结点
    int count=0;
    while(p!=NULL&&count<i-1)//查找第i-1个结点
    {
        p=p->next;
        count++;
    }
    if(p==NULL)throw"插入位置错误";
    else
    {
        s=new Node<DataType>;//申请新的结点s
        s->data=x;//s的数据域为x
        s->next=p->next;//s的指针域指向p结点的下一个结点
        p->next=s;//p的指针域指向s
    }

}
template<typename DataType>
LinkList<DataType>::LinkList(DataType a[],int n)
{//创建单链表（头插法和尾插法）
//头插法，顺序是反的
    first=new Node<DataType>;
    first->next=NULL;//创建一个空表
    for(int i=0;i<n;i++)
    {
        Node<DataType>*s=new Node<DataType>;
        s->data=a[i];
        //申请一个新结点s,数据域为a[i]
        s->next=first->next;
        first->next=s;//将s插入到first头结点后
    }
}
/*
template<typename DataType>
LinkList<DataType>::LinkList(DataType a[],int n)
{//尾插法,顺序正常
    first=new Node<DataType>;//生成头结点
    Node<DataType>*rear=first;//尾指针初始化
    for(int i=0;i<n;i++)
    {
        Node<DataType>*s=new Node<DataType>;
        s->data=a[i];
        //申请一个新结点s,数据域为a[i]
        r->next=s;//尾指针的指针域指向s
        r=s；//s成为新的尾指针
    }
    rear->next=NULL;//创建完毕，将终端指针置空
}
*/
template<typename DataType>
DataType LinkList<DataType>::delete1(int i)
{//删除某个结点
    DataType x;//存放被删除结点的数据域
    Node<DataType>*p=first,*q=NULL;//q为被删除结点
    int count=0;
    while(p!=NULL&&count<i-1)
    {
        p=p->next;
        count++;
    }
    if(p==NULL||p->next==NULL)throw"删除位置有误";
    //结点不存在或者结点的后继结点不存在
    else
    {
        q=p->next;x=q->data;//暂存被删节点
        p->next=q->next;//摘链
        return x;
    }
}
template<typename DataType>
LinkList<DataType>::~LinkList()
{//销毁
    Node<DataType>*p=NULL;
    while(first!=NULL)
    {
        p=first;
        first=first->next;
        delete p;
    }
}
int main()
{
    int a[]={1,2,3};
    LinkList<int>L(a,3);
    cout<<"输出当前单链表："<<endl;
    L.print();
    cout<<"查找单链表第一位：";
    cout<<L.get(1)<<endl;
    try
    {
        L.insert(2,2);
    }catch(char* str){cout<<str<<endl;}
    cout<<"输出插入元素后单链表："<<endl;
    L.print();
    if(L.empty()==1)cout<<"链空"<<endl;
    cout<<"链非空"<<endl;
    return 0;
}