#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;
}