c[i][j]+=a[i][k]*b[k][j];//n3
}
【程序3-1】伸展树类
#include
enumResultCode{Underflow,Overflow,Success,Duplicate,Fail,NotPresent};
template
structBTNode
{//二叉树结点类
BTNode（constT&x）
{
element=x;lChild=rChild=NULL;
}
Telement;
BTNode*lChild,*rChild;
};
template
classSPTree
{//伸展树类
public:
SPTree（）{root=NULL;}
ResultCodeInsert（Tx）;
protected:
BTNode*root;
private:
ResultCodeInsert（BTNode*&p,Tx）;
voidLRot（BTNode*&p）;
voidRRot（BTNode*&p）;
};
【程序3-2】旋转函数
template
voidSPTree:
:
LRot（BTNode*&p）
{//前置条件：
p有右孩子，实现向左旋转
BTNode*r=p->rChild;
p->rChild=r->lChild;
r->lChild=p;p=r;//p的右孩子成为子树根
}
template
voidSPTree:
:
RRot（BTNode*&p）
{//前置条件：
p有左孩子，实现向右旋转
BTNode*r=p->lChild;
p->lChild=r->rChild;
r->rChild=p;p=r;//p的左孩子成为子树根
}
【程序3-3】伸展树插入
template
ResultCodeSPTree:
:
Insert（Tx）
{
returnInsert（root,x）;
}
template
ResultCodeSPTree:
:
Insert（BTNode*&p,Tx）
{//假定T类上已重载了关系运算符或类型转换运算符①
ResultCoderesult=Success;
BTNode*r;
if（p==NULL）{//插入新结点
p=newBTNode（x）;returnresult;
}
if（x==p->element）{
result=Duplicate;returnresult;
}
if（xelement）{
r=p->lChild;
if（r==NULL）{//zig旋转
r=newBTNode（x）;r->rChild=p;p=r;
returnresult;
}
elseif（x==r->element）{//zig旋转
RRot（p）;result=Duplicate;returnresult;
}
if（xelement）{//zigzig旋转
result=Insert（r->lChild,x）;
RRot（p）;
}
else{//zigzag旋转
result=Insert（r->rChild,x）;
LRot（r）;p->lChild=r;
}
RRot（p）;
}
else{
r=p->rChild;
if（r==NULL）{
r=newBTNode（x）;r->lChild=p;p=r;
returnresult;
}
elseif（x==r->element）{
LRot（p）;//zag旋转
result=Duplicate;returnresult;
}
if（x>r->element）{//zagzag旋转
result=Insert（r->rChild,x）;
LRot（p）;
}
else{//zagzig旋转
result=Insert（r->lChild,x）;
RRot（r）;p->rChild=r;
}
LRot（p）;
}
returnresult;
}
【程序3-4】跳表结点类
template
structSNode
{
SNode（intmSize）
{
link=newSNode*[mSize];
}
~SNode（）{delete[]link;}
Telement;
SNode**link;
};
【程序3-5】跳表类
template
classSkipList
{
public:
SkipList（Tlarge,intmLev）;
~SkipList（）;
ResultCodeInsert（Tx）;//函数定义见3.1.1节
private:
intLevel（）;
SNode*SaveSearch（Tx）;
intmaxLevel,levels;
SNode*head,*tail,**last;
};
【程序3-6】构造函数
template
SkipList:
:
SkipList（Tlarge,intmLev）
{
maxLevel=mLev;levels=0;
head=newSNode（maxLevel+1）;//指向包括元素域和maxLevel+1个指针的头结点
tail=newSNode（0）;//指向只有元素域，不包含指针域的尾结点
last=newSNode*[maxLevel+1];//maxLevel+1个指针
tail->element.key=large;//尾结点中保存作为哨兵值的最大值large
for（inti=0;i<=maxLevel;i++）
head->link[i]=tail;//头结点的所有指针指向尾结点
}
【程序3-7】级数分配
template
intSkipList:
:
Level（）
{
intlev=0;
while（rand（）<=RAND_MAX/2）lev++;
return（lev<=maxLevel）？
lev:
maxLevel;
}
【程序3-8】插入运算
enumResultCode{Underflow,Overflow,Success,Duplicate,RangeError,NotPresent};
template
SNode*SkipList:
:
SaveSearch（Tx）
{//假定T类已重载了关系运算符或类型转换运算符
SNode*p=head;
for（inti=levels;i>=0;i--）{
while（p->link[i]->elementlink[i];
last[i]=p;//将最后搜索到的第i层结点的地址保存在last[i]中
}
return（p->link[0]）;
}
template
ResultCodeSkipList:
:
Insert（Tx）
{
if（x>=tail->element）returnRangeError;
SNode*p=SaveSearch（x）;
if（p->element==x）returnDuplicate;//表明有重复元素
intlev=Level（）;//计算级数
if（lev>levels）{
lev=++levels;last[lev]=head;
}
SNode*y=newSNode（lev+1）;//构造新结点
y->element=x;
for（inti=0;i<=lev;i++）{//新结点插入各级链中
y->link[i]=last[i]->link[i];
last[i]->link[i]=y;
}
returnSuccess;
}
【程序4-1】ENode类
enumColorType{White,Gray,Black};
structENode
{
intadjVex;
ENode*nextArc;
};
classGraph
{
public:
Graph（intmSize）
{//构造仅有n个结点的图的邻接表
n=mSize;
a=newENode*[n];
for（inti=0;i}
voidDFS_Traversal（int*parent）;//一维数组parent保存DFS生成森林
voidBFS_Traversal（int*prarent）;//一维数组parent保存BFS生成森林
protected:
voidDFS（intu,int*parent,ColorType*color）;//递归DFS函数访问从u可达结点
voidBFS（intu,int*parent,ColorType*color）;//BFS函数访问从u可达结点
ENode**a;//生成指向ENode类对象的指针数组
intn;//图中结点数目
};
【程序4-2】图的广度优先遍历
voidGraph:
:
BFS_Traversal（int*parent）
{//遍历算法将在parent数组中返回以双亲表示法表示的BFS生成森林
ColorType*color=newColorType[n];//颜色数组
cout<";
for（intu=0;ucolor[u]=White;parent[u]=-1;
}
for（u=0;uif（color[u]==White）BFS（u,parent,color）;//从未标记的结点出发进行BFS
delete[]color;
cout<}
voidGraph:
:
BFS（intu,int*parent,ColorType*color）
{//广度优先搜索算法
Queueq（QSize）;
color[u]=Gray;cout<<""<q.Append（u）;//将起始结点u加入队列q
while（！
q.IsEmpty（））{
u=q.Front（）;q.Serve（）;//选择一个活结点为E-结点
for（ENode*w=a[u];w;w=w->nextArc）{//检测E-结点u的全部邻接点
intv=w->adjVex;
if（color[v]==White）{
color[v]=Gray;cout<<""<parent[v]=u;//构造BFS生成森林
q.Append（v）;//新的活结点进入活结点表q
}
}
color[u]=Black;//标记死结点
}
}
【程序4-3】图的深度优先搜索
voidGraph:
:
DFS（intu,int*parent,ColorType*color）
{
color[u]=Gray;cout<<""<d[u]=time++;//记录第1个时间
for（ENode*w=a[u];w;w=w->nextArc）{
intv=w->adjVex;
if（color[v]==White）{
parent[v]=u;
DFS（v,parent,color）;
}
}
color[u]=Black;f[u]=time++;//记录第2个时间
}
【程序4-4】计算d和Low
voidGraph:
:
DFS（intu,intp）
{//u是起始结点，p是u的双亲结点
Low[u]=d[u]=time++;//Low[u]=d[u]
for（ENode*w=a[u];w;w=w->nextArc）{
intv=w->adjVex;
if（d[v]==-1）{//表示v尚未访问
DFS（v,u）;
if（Low[u]>Low[v]）Low[u]=Low[v];//是树边
}
elseif（v！
=p&&Low[u]>d[v]）Low[u]=d[v]//是反向边
}
}
【程序4-5】求双连通分量
voidGraph:
:
BiCom（intu,intp）
{
Low[u]=d[u]=time++;eNodee;
for（ENode*w=a[u];w;w=w->nextArc）{
intv=w->adjVex;
e.u=u;e.v=v;
if（v！
=p&&d[v]if（d[v]==-1）{
BiCom（v,u）;
if（Low[v]>=d[u]）{
cout<do{
e=s.Top（）;s.Pop（）;
if（ue.v）Swap（e.u,e.v）;
elseif（u>v&&e.ucout<<"（"<}while（e.u！
=u||e.v！
=v）;
}
if（Low[u]>Low[v]）Low[u]=Low[v];
}
elseif（v！
=p&&Low[u]>d[v]）Low[u]=d[v];
}
}
【程序4-6】与或树及其结点类型
enumNType{A,O,S,U};
template
structTNode
{
TNode（constT&x,intd,NTypec）
{
element=x;tp=c;
p=newTNode*[d];
for（inti=0;i}
Telement;//元素
NTypetp;//结点类型
TNode**p;//指向孩子的指针
};
template
classAndOrTree
{
public:
AndOrTree（intdegree）;
intSolvable（）
{
returnPostOrder（root）;
}
……
private:
intPostOrder（TNode*t）;//判定与或树是否可解
……
TNode*root;
intd;
};
【程序4-7】判断与或树是否可解算法
template
intAndOrTree:
:
PostOrder（TNode*t）
{
inti;
switch（t->tp）{
caseS:
return1;
caseU:
return0;
caseA:
for（i=0;ip[i]&&！
Post
升级会员 