#include
#include
#include
usingnamespacestd;
template
classarraylist
{
public:
arraylist(intintialcapacity=10);
arraylist(constarraylist&);
~arraylist(){
delete[]element;
}
voidchangelength1d(T*&a,intoldlength,intnewlength)
{
T*temp=newT[newlength];
intnumber=min(oldlength,newlength);
copy(a,a+number,temp);
delete[]a;
a=temp;
}
boolempty()const{returnlistsize==0;}
intsize()const{returnlistsize;}
T&get(inttheindex)const;
intindexof(constT&theelement)const;
voiderase(inttheindex);
voidinsert(inttheindex,constT&theelement);
voidoutput(ostream&out)const;
voidclear()
{
listsize=0;
}
voidreset(intnewsize)
{
listsize=newsize;
if(listsize>arraylength)
{
arraylength=newsize;
delete[]element;
element=newT[arraylength];
}
}
voidset(inttheindex,constT&theelement);
voidcopymatrix(constarraylist&terms);
classiterator
{
public:
typedefbidirectional_iterator_tagiterator_category;
typedefTvalue_type;
typedefptrdiff_tdifference_type;
typedefT*pointer;
typedefT&reference;
iterator(T*theposition=0){
position=theposition;
}
T&operator*()const{
return*position;
}
T*operator->()const{return&*position;}
iterator&operator++()
{
++position;return*this;
}
iteratoroperator++(int)
{
iteratorold=*this;
++position;
returnold;
}
iterator&operator--()
{
--position;return*this;
}
iteratoroperator--(int)
{
iteratorold=*this;
--position;
returnold;
}
iteratoroperator+(intn)
{
iteratorold=*this;
returnold+=n;
}
iterator&operator+=(intn)
{
position=position+n;
return*this;
}
iteratoroperator-(intn)
{
iteratorold=*this;
returnold-=n;
}
iterator&operator-=(intn)
{
position=position-n;
return*this;
}
booloperator!=(constiteratorright)const
{
returnposition!=right.position;
}
booloperator==(constiteratorright)const
{
returnposition==right.position;
}
protected:
T*position;
};
iteratorbegin(){returniterator(element);}
iteratorend(){returniterator(element+listsize);}
protected:
T*element;
intarraylength;
intlistsize;
};
template
arraylist::arraylist(intinitialcapacity)
{
if(initialcapacity
arraylist::arraylist(constarraylist&thelist)
{
arraylength=thelist.arraylength;
listsize=thelist.listsize;
element=newT[arraylength];
copy(thelist.element,thelist.element+listsize,element);
}
template
voidarraylist::insert(inttheindex,constT&theelement)
{
if(theindexlistsize)
return;
if(listsize==arraylength)
{
changelength1d(element,arraylength,2*arraylength);
arraylength*=2;
}
copy_backward(element+theindex,element+listsize,element+listsize+1);
element[theindex]=theelement;
listsize++;
}
template
voidarraylist::set(inttheindex,constT&theelement)
{
element[theindex]=theelement;
listsize++;
}
template
voidarraylist::copymatrix(constarraylist&thelist)
{
arraylength=thelist.arraylength;
listsize=thelist.listsize;
delete[]element;
element=newT[arraylength];
copy(thelist.element,thelist.element+listsize,element);
}
template
structmatrixterm
{
public:
introw;
intcol;
Tvalue;
};
template
classsparsematrix
{
public:
voidtranspose(sparsematrix&b);
voidadd(sparsematrix&b,sparsematrix&c);
voidmulti(sparsematrix&b,sparsematrix&c);
introws,cols;
arraylist>terms;
};
template
voidsparsematrix::add(sparsematrix&b,sparsematrix&c)
{
if(rows!=b.rows||cols!=b.cols)
return;
c.rows=rows;
c.cols=cols;
c.terms.clear();
intcsize=0;
typenamearraylist>::iteratorit=terms.begin();
typenamearraylist>::iteratorib=b.terms.begin();
typenamearraylist>::iteratoritend=terms.end();
typenamearraylist>::iteratoribend=b.terms.end();
while(it!=itend&&ib!=ibend)
{
inttindex=(*it).row*cols+(*it).col;
intbindex=(*ib).row*cols+(*ib).col;
if(tindexmterm;
mterm.row=(*it).row;
mterm.col=(*it).col;
mterm.value=(*it).value+(*ib).value;
c.terms.insert(csize++,mterm);
}
it++;
ib++;
}
else
{
c.terms.insert(csize++,*ib);
ib++;
}
}
}
for(;it!=itend;it++)
c.terms.insert(csize++,*it);
for(;ib!=ibend;ib++)
c.terms.insert(csize++,*ib);
}
template
voidsparsematrix::transpose(sparsematrix&b)
{
b.cols=rows;
b.rows=cols;
b.terms.reset(terms.size());
int*colsize=newint[cols+1];
int*rownext=newint[cols+1];
for(inti=1;i>::iteratori=terms.begin();i!=terms.end();i++)
colsize[(*i).col]++;
rownext[1]=0;
for(inti=2;imterm;
for(typenamearraylist>::iteratori=terms.begin();i!=terms.end();i++)
{
intj=rownext[(*i).col]++;
mterm.row=(*i).col;
mterm.col=(*i).row;
mterm.value=(*i).value;
b.terms.set(j,mterm);
}
}
template
voidsparsematrix::multi(sparsematrix&b,sparsematrix&c)
{
c.rows=rows;
c.cols=b.rows;
intcsize=0;
int**m=newint*[rows];
for(inti=0;i::iteratorit=terms.begin();
typenamearraylist>::iteratorib=b.terms.begin();
for(inti=1;imterm;
mterm.row=i;
mterm.col=j;
mterm.value=sum;
c.terms.insert(csize++,mterm);
}
}
for(inti=0;i>n;
for(inti=1;i>num;
switch(num)
{
case(1):
{
sparsematrixa1;
asize=0;
cin>>row1;
cin>>col1;
a1.rows=row1;
a1.cols=col1;
for(inti=1;i>p;
if(p!=0)
{
matrixtermmterm1;
mterm1.row=i;
mterm1.col=j;
mterm1.value=p;
a1.terms.insert(asize++,mterm1);
}
}
}
a.rows=a1.rows;
a.cols=a1.cols;
a.terms.copymatrix(a1.terms);
break;
}
case(2):
{
sparsematrixb;
sparsematrixd;
bsize=0;
cin>>row2;
cin>>col2;
b.rows=row2;
b.cols=col2;
for(inti=1;i>p;
if(p!=0)
{
matrixtermmterm2;
mterm2.row=i;
mterm2.col=j;
mterm2.value=p;
b.terms.insert(bsize++,mterm2);
}
}
}
if(a.cols!=b.rows)
{
a.rows=b.rows;
a.cols=b.cols;
cout>row2;
cin>>col2;
b.rows=row2;
b.cols=col2;
for(inti=1;i>p;
if(p!=0)
{
matrixtermmterm2;
mterm2.row=i;
mterm2.col=j;
mterm2.value=p;
b.terms.insert(bsize++,mterm2);
}
}
}
if(a.rows!=b.rows||a.cols!=b.cols)
{
a.rows=b.rows;
a.cols=b.cols;
cout -->
|
