数据结构（用面象对象方法与C++语言描述）线性表

#include <iostream>//顺序表 Page47
using namespace std;
#include <stdlib.h>
const int defaultSize=100;
template <class T>
class SeqList
{
protected:
    T *data;
    int maxSize;
    int last;
    void reSize(int newSize);
public:
    SeqList(int sz=defaultSize);
    SeqList(SeqList<T>& L);
    ~SeqList(){delete[] data;}
    int Size()const{return maxSize;}
    int Length()const{return last+1;}
    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)const
    {if(i>0&&i<=last+1) 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-1)?true:false;}
    void input();
    void output();
    SeqList<T> operator=(SeqList<T>& L);
};

template <class T>
SeqList<T>::SeqList(int sz){
    if(sz>0){
        maxSize=sz;last=-1;
        data=new T[maxSize];
        if(data==NULL)
        {cerr<<"存储分配错误！"<<endl;exit(1);}
    }
}
//构造函数与复制构造函数
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)
    {cerr<<"存储分配错误！"<<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)
    {cerr<<"无效的数组大小"<<endl;return;}
    if(newSize!=maxSize){
        T *newarray=new T[newSize];
        if(newarray==NULL)
        {cerr<<"存储分配错误"<<endl;exit(1);}
        int n=last+1;
        T *srcptr=data;
        T *destptr=newarray;
        while(n--)*destptr++=*srcptr++;
        delete []data;
        data=newarray;maxSize=newSize;
    }
}
//搜索与定位
template<class T>
int SeqList<T>::Search(T& x)const{
    for(int i=0;i<=last;i++)
        if(data[i]==x) return i+1;
    return 0;
}

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) return false;
    if(i<0||i>last+1) return false;
    for(int j=last;j>=i;j--)
        data[j+1]=data[j];
    data[i]=x;
    last++;
    return true;
}

template<class T>
bool SeqList<T>::Remove(int i, T &x){
    if(last==-1) return false;
    if(i<1||i>last+1) return false;
    x=data[i-1];
    for(int j=i;j<=last;j++)
        data[j-1]=data[j];
    last--;
    return true;
}
//输入输出和赋值
template<class T>
void SeqList<T>::input(){
    cout<<"开始建立顺序表，请输入表中元素个数：";
    while(1){
        cin>>last;
        if(last<=maxSize-1) break;
        cout<<"表元素个数有误，范围不能超过"<<maxSize-1<<": ";
    }
    for(int i=0;i<last;i++)
    {cin>>data[i];cout<<i+1<<endl;}
}

template<class T>
void SeqList<T>::output(){
    cout<<"顺序表当前元素最后位置为："<<last<<endl;
    for(int i=0;i<=last;i++)
        cout<<"#"<<i+1<<":"<<data[i]<<endl;
}

#include <iostream>//单链表模板 Page62
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(){first=new LinkNode<T>;}
    List(const T&x) {first=new LinkNode<T>(x);}
    List(List<T>& L);
    ~List(){makeEmpty();}
    void makeEmpty();
    int Length()const;
    LinkNode<T> *getHead()const{return first;}
    LinkNode<T> *Search(T x);
    LinkNode<T> *Locate(int i);
    bool getData(int i,T& x)const;
    void setData(int i,T& x);
    bool Insert(int i,T& x);
    bool Remove(int i,T& x);
    bool IsEmpty()const
    {return first->link==NULL?true:false;}
    bool IsFull()const{return false;}
    void Sort();
    void input();
    void output();
    List<T>& operator=(List<T>& L);
protected:
    LinkNode<T> *first;
};
//复制构造函数
template <class T>
List<T>::List(List<T>& L){
    T value;
    LinkNode<T> *srcptr=L.getHead();
    LinkNode<T> *destptr=first=new LinkNode<T>;
    while(srcptr->link!=NULL){
        value=srcptr->link->Data;
        destptr->link=new LinkNode<T>(value);
        destptr=destptr->link;
        srcptr=srcptr->link;
    }
    destptr->link=NULL;
};
//将链表置为空表
template <class T>
void List<T>::makeEmpty(){
    LinkNode<T> *q;
    while(first->link!=NULL){
        q=first->link;
        first->link=q->link;
        delete q;
    }
};
//计算带附加头结点的单链表长度
template <class T>
int List<T>::Length()const{
    LinkNode<T> *p=first->link;int count=0;
    while(p!=NULL)
    {p=p->link;count++;}
    return count;
};
//在表中搜索含数据x的结点，搜索成功时返回结点地址
template <class T>
LinkNode<T>* List<T>::Search(T x){
    LinkNode<T> *current=first->link;
    while(current!=NULL)
        if(current->data==x) break;
        else current=current->link;
    return current;
};
//定位函数，返回表中第i个元素的地址，i<0或超出结点个数返回NULL
template <class T>
LinkNode<T>* List<T>::Locate(int i){
    if(i<0) return NULL;
    LinkNode<T> *current=first;int k=0;
    while(current!=NULL&&k<i)
      {current=current->link;k++;}
    return current;
};
//取出链表中第i个元素的值
template <class T>
bool List<T>::getData(int i, T &x)const{
    if(i<0) return NULL;
    LinkNode<T> *current=Locate(i);
    if(current==NULL) return false;
    else{x=current->data;return true;}
};
//给链表中第i个元素赋值x
template <class T>
void List<T>::setData(int i, T &x){
    if(i<=0) return;
    LinkNode<T> *current=Locate(i);
    if(current==NULL) return;
    else current->data=x;
};
//将新元素x插在链表中第i个结点之后
template <class T>
bool List<T>::Insert(int i, T &x){
    LinkNode<T> *current=Locate(i);
    if(current==NULL) return false;
    LinkNode<T> *newNode=new LinkNode<T>(x);
    if(newNode==NULL) {cerr<<"存储分配错误！"<<endl;exit(1);}
    newNode->link=current->link;
    current->link=newNode;
    return true;
};
//将链表中第i个元素删去，通过引用型参数x返回该元素的值
template <class T>
bool List<T>::Remove(int i, T &x){
    LinkNode<T> *current=Locate(i-1);
    if(current==NULL||current->link==NULL) return  false;
    LinkNode<T> *del=current->link;
    current->link=del->link;
    x=del->data;delete del;
    return true;
};
//单链表的输出函数
template <class T>
void List<T>::output(){
    LinkNode<T> *current=first->link;
    while(current!=NULL){
        cout<<current->data<<endl;
        current=current->link;
    }
};
//重载函数：赋值操作，形如A＝B，其中A是调用此操作的List对象，B是与引用型参数L结合的实参
template <class T>
List<T>& List<T>::operator=(List<T> &L){
    T value;
    LinkNode<T> *srcptr=L.getHead();
    LinkNode<T> *destptr=first=new LinkNode<T>;
    while(srcptr->link!=NULL){
        value=srcptr->link->data;
        destptr->link=new LinkNode<T>(value);
        destptr=destptr->link;
        srcptr=srcptr->link;
    }
    destptr->link=NULL;
    return *this;
};

#include <iostream>//双向循环链表的类定义 Page72
using namespace std;
template<class T>
struct DblNode{
    T data;
    DblNode<T> *lLink,*rLink;
    DblNode(DblNode<T> *left=NULL,DblNode<T> *right=NULL):lLink(left),rLink(right){}
    DblNode(T value,DblNode<T> *left=NULL,DblNode<T> *right=NULL)
    :data(value),lLink(left),rLink(right){}
};

template<class T>
class DblList{
public:
    DblList(T uniqueVal);
    ~DblList();
    int Length()const;
    bool IsEmpty(){return first->rLink==first;}
    DblNode<T> *getHead()const{return first;}
    void setHead(DblNode<T> *ptr){first=ptr;}
    DblNode<T> *Search(const T& x);
    DblNode<T> *Locate(int i,int d);
    bool Insert(int i,const T& x,int d);
    bool Remove(int i,T& x,int d);
private:
    DblNode<T> *first;
};
//构造函数:建立双向循环链表的附加头结点，它包含了一个用于某些特定情况的值
template <class T>
DblList<T>::DblList(T uniqueVal){
    first=new DblNode<T>(uniqueVal);
    if(first==NULL){cerr<<"存储分配出错！"<<endl;exit(1);}
    first->rLink=first->lLink=first;
};
//计算带附加头结点的双向循环链表长度
template <class T>
int DblList<T>::Length()const{
    DblNode<T> *current=first->link;int count=0;
    while(current!=first){current=current->rLink;count++;}
    return count;
};
//在表中搜索含数据x的结点，搜索成功时返回结点地址
template <class T>
DblNode<T>* DblList<T>::Search(const T& x){
    DblNode<T> *current=first->link;
    while(current!=first&¤t->data!=x)
        current=current->rLink;
    if(current!=first) return current;
    else return NULL;
};
//定位函数，返回表中第i个元素的地址，i<0或超出结点个数返回NULL
template <class T>
DblNode<T>* DblList<T>::Locate(int i,int d){
    if(first->rLink==first||i==0) return first;
    DblNode<T> *current;
    if(d==0) current=first->lLink;
    else current=first->rLink;
    for(int j=1;j<i;j++)
        if(current==first) break;
        else if(d==0)current=current->lLink;
        else current=current->rLink;
    if(current!=first) return current;
    else return NULL;
};
//将新元素x插在链表中第i个结点之后
template <class T>
bool DblList<T>::Insert(int i,const T &x,int d){
    DblNode<T> *current=Locate(i,d);
    if(current==NULL) return false;
    DblNode<T> *newNode=new DblNode<T>(x);
    if(newNode==NULL) {cerr<<"存储分配错误！"<<endl;exit(1);}
    if(d==0){
    newNode->lLink=current->lLink;
    current->lLink=newNode;
    newNode->lLink->rLink=newNode;
    newNode->rLink=current;
    }
    else{
    newNode->rLink=current->rLink;
    current->rLink=newNode;
    newNode->rLink->lLink=newNode;
    newNode->lLink=current;

    }
    return true;
};
//将链表中第i个元素删去，通过引用型参数x返回该元素的值
template <class T>
bool DblList<T>::Remove(int i, T &x,int d){
    DblNode<T> *current=Locate(i,d);
    if(current==NULL) return false;
    current->rLink->lLink=current->lLink;
    current->lLink->rLink=current->rLink;
    x=current->data;delete current;
    return true;
};

#include <iostream>//多项式的类定义 P74
#include <cmath>
using namespace std;
struct Term//多项式结点的定义
{
    float coef;
    int exp;
    Term *link;
    Term(float c,int e,Term *next=NULL)
    {coef=c;exp=e;link=next;}
    Term *InsertAfter(float c,int e);
    friend ostream &operator<<(ostream&,const Term&);
};
struct Polynomial{
public:
    Polynomial(){first=new Term(0,-1);}
    Polynomial(Polynomial &R);
    int maxOrder();
    Term *getHead() const {return first;}
private:
    Term *first;
    friend ostream &operator<<(ostream&,const Term&);
    friend istream &operator>>(istream&,Term&);
    friend Polynomial operator +(Polynomial&,Polynomial&);
    friend Polynomial operator *(Polynomial&,Polynomial&);
};
//在当前由this指针指示的项后面插入一个新项
Term *Term::InsertAfter(float c, int e){
    link=new Term(c,e,link);
    return link;
}
//输出一个项x的内容到输出流中
ostream &operator<<(ostream& out,const Term& x){
    if(x.coef==0.0) return out;
    out<<x.coef;
    switch(x.exp){
        case 0:break;
        case 1:out<<"X";break;
        default:out<<"X"<<x.exp;break;
    }
    return out;
};
//复制构造函数：用已有多项式对象R初始化当前多项式对象R
Polynomial::Polynomial(Polynomial &R){
    first=new Term(0,-1);
    Term *destptr=first,*srcptr=R.getHead()->link;
    while(srcptr!=NULL){
        destptr->InsertAfter(srcptr->coef,srcptr->exp);
        srcptr=srcptr->link;
        destptr=destptr->link;
    }
};
//计算最大阶数，当多项式按升序排列时，最后一项中是指数最大者
int Polynomial::maxOrder(){
    Term *current=first;
    while(current->link!=NULL) current=current->link;
    return current->exp;
};
//从输入流输入各项，用尾插入法建立一个多项式
istream& operator>>(istream &in,Polynomial& x){
    Term *rear=x.getHead();int c,e;
    while(1){
        cout<<"input a term(coef,exp):"<<endl;
        in>>c>>e;
        if(e<0) break;
        rear=rear->InsertAfter(c,e);
    }
    return in;
};
//输出带附加头结点的多项式链表x
ostream &operator<<(ostream &out,Polynomial& x){
    Term *current=x.getHead()->link;
    cout<<"The polynomal is:"<<endl;
    bool h=true;
    while(current!=NULL){
        if(h==false&¤t->coef>0.0) out<<"+";
    h=false;
        out<<*current;
        current=current->link;
    }
    out<<endl;
    return out;
};
//两个多项式相加的运算
Polynomial operator +(Polynomial&A,Polynomial&B){
    Term *pa,*pb,*pc,*p;float temp;
    Polynomial C;pc=C.first;
    pa=A.getHead()->link;pb=B.getHead()->link;
    while(pa!=NULL&&pb!=NULL){
        if(pa->exp==pb->exp){
            temp=pa->coef+pb->coef;
            if(fabs(temp)>0.001)
                pc=pc->InsertAfter(temp,pa->exp);
            pa=pa->link;pb=pb->link;
        }
        else if(pa->exp<pb->exp){
            pc=pc->InsertAfter(pa->coef,pa->exp);
            pa=pa->link;
        }
        else{
            pc=pc->InsertAfter(pb->coef,pb->exp);
            pb=pb->link;
        }
    }
    if(pa!=NULL) p=pa;
    else p=pb;
    while(p!=NULL){
        pc=pc->InsertAfter(p->coef,p->exp);
        p=p->link;
    }
    return C;
}
//两个多项式相乘的运算
Polynomial operator *(Polynomial&A,Polynomial&B){
    Term *pa,*pb,*pc;int AL,BL,i,k,maxExp;
    Polynomial C;
    pc=C.getHead();
    AL=A.maxOrder();BL=B.maxOrder();
    if(AL!=-1&&BL!=-1){
        maxExp=AL+BL;
        float *result=new float[maxExp+1];
        for(i=0;i<maxExp;i++) result[i]=0.0;
        pa=A.getHead()->link;
        while(pa!=NULL){
            pb=B.getHead()->link;
            while(pb!=NULL){
                k=pa->exp+pb->exp;
                result[k]=result[k]+pa->coef*pb->coef;
                pb=pb->link;
            }
            pa=pa->link;
        }
        for(i=0;i<maxExp;i++)
            if(fabs(result[i])>0.001) pc=pc->InsertAfter(result[i],i);
        delete[] result;
    }
    pc->link=NULL;
    return C;
};

#include <iostream>//静态链表定义 Page81
using namespace std;
const int maxSize=100;
template <class T>
struct SLinkNode{
    T data;
    int link;
};
template <class T>
class StaticList{
    SLinkNode<T> elem[maxSize];
    int avil;
public:
    void InitList();
    int Length();
    int Search(T x);
    int Locate(int i);
    bool Append(T x);
    bool Insert(int i,T x);
    bool Remove(int i);
    bool IsEmpty();
};
//将链表空间初始化
template <class T>
void StaticList<T>::InitList(){
    elem[0].link=-1;avil=1;
    for(int i=0;i<maxSize-1;i++)
        elem[i].link=i+1;
    elem[maxSize-1].link=-1;
};
//计算静态链表的长度
template <class T>
int StaticList<T>::Length(){
    int p=elem[0].link;int i=0;
    while(p!=-1){
        p=elem[p].link;i++;
    }
    return i;
}
//判断是否为空链表
template <class T>
bool StaticList<T>::IsEmpty(){
    if(elem[0].link==-1) return true;
    else return false;
}
//在静态链表中找具有给定值的结点
template <class T>
int StaticList<T>::Search(T x){
    int p=elem[0].link;
    while(p!=-1)
        if(elem[p].data==x) break;
        else p=elem[p].link;
    return p;
}
//在静态链表中查找第i个结点
template <class T>
int StaticList<T>::Locate(int i){
    if(i<0) return -1;
    if(i==0) return 0;
    int j=1,p=elem[0].link;
    while(p!=-1&&j<i)
    {p=elem[p].link;j++;}
    return p;
}
//在静态链表的表尾追加一个新结点
template <class T>
bool StaticList<T>::Append(T x){
    if(avil==-1) return false;
    int q=avil;
    avil=elem[avil].link;
    elem[q].data=x;elem[q].link=-1;
    int p=0;
    while(elem[p].link!=-1)
        p=elem[p].link;
    elem[p].link=q;
    return true;
}
//在静态链表第i个结点后面插入新结点
template <class T>
bool StaticList<T>::Insert(int i, T x){
    int p=Locate(i);
    if(p==-1) return false;
    int q=avil;
    avil=elem[avil].link;
    elem[q].data=x;
    elem[q].link=elem[p].link;
    elem[p].link=q;
    return true;
}
//在静态链表中释放第i个结点
template <class T>
bool StaticList<T>::Remove(int i){
    int p=Locate(i-1);
    if(p==-1) return false;
    int q=elem[p].link;
    elem[p].link=elem[q].link;
    elem[q].link=avil;
    avil=q;
    return true;
}