数据结构上机作业6-10章

6.33③ 假定用两个一维数组L[1..n]和R[1..n]作为

有n个结点的二叉树的存储结构， L[i]和R[i]分别指

示结点i的左孩子和右孩子，0表示空。试写一个算法

判别结点u是否为结点v的子孙。

要求实现以下函数：

Status Dencendant(Array1D L,Array1D R,intn,int u,int v);

一维数组类型Array1D的定义：

typedef int Array1D[MAXSIZE];

Status Dencendant(Array1D L,Array1D R,intn,int u,int v)

{if(L[v]==u||R[v]==u) return TRUE;

if(L[v])

if(Dencendant(L,R,n,u,L[v])) return TRUE;

if(R[v])

if( Dencendant(L,R,n,u,R[v]) )return TRUE;

else return FALSE;

}

6.34③ 假定用两个一维数组L[1..n]和R[1..n]作为

有n个结点的二叉树的存储结构， L[i]和R[i]分别指

示结点i的左孩子和右孩子，0表示空。试写一个算法,

先由L和R建立一维数组T[1..n]，使T中第i(i=1,2,...,

n)个分量指示结点i的双亲，然后判别结点u是否为结

点v的子孙。

要求实现以下函数：

Status Dencend(Array1D L, Array1D R, int n,int u, int v, Array1D T);

一维数组类型Array1D的定义：

typedef int Array1D[MAXSIZE];

Status Dencend(Array1D L, Array1D R, int n,int u, int v, Array1D T)

{int i;

for( i = 1; i <= n; ++i )

T[L[i]] = i;

for( i = 1; i <= n; ++i )

T[R[i]] = i;

while(T[u]!=0)

{

if(T[u]==v)

return TRUE;

u=T[u];

}

return FALSE;

}

6.36③ 若已知两棵二叉树B1和B2皆为空，或者皆

不空且B1的左、右子树和B2的左、右子树分别相似，

则称二叉树B1和B2相似。试编写算法，判别给定两

棵二叉树是否相似。

要求实现下列函数：

Status Similar(BiTree t1, BiTree t2);

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

Status Similar(BiTree t1, BiTree t2)

{ if(!t1&&!t2) return TRUE;

if(t1&&t2)

if(Similar(t1->lchild,t2->lchild))

if(Similar(t1->rchild,t2->rchild)) return TRUE;

else return FALSE;

}

6.37③试直接利用栈的基本操作写出先序遍历的非递归

形式的算法(提示:不必按3.3.2节介绍的从递归到非递归

的方法而直接写出非递归算法)。

要求实现下列函数：

void PreOrder(BiTree bt, void(*visit)(TElemType));

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild,*rchild;

} BiTNode, *BiTree;

可用栈类型Stack的相关定义：

typedef BiTree SElemType; // 栈的元素类型

Status InitStack(Stack &S);

Status StackEmpty(Stack S);

Status Push(Stack &S, SElemType e);

Status Pop(Stack &S, SElemType &e);

Status GetTop(Stack S, SElemType &e);

void PreOrder(BiTree bt, void(*visit)(TElemType))

{ Stack S;

InitStack(S);

BiTree p;

if(!bt) return ;

p=bt;

while(p||!StackEmpty(S))

{if(p)

{visit(p->data);

Push(S,p);

p=p->lchild;}

else

{Pop(S,p);

p=p->rchild;

}

}

}

6.38④同6.37题条件，写出后序遍历的非递归算法

(提示：为分辨后序遍历时两次进栈的不同返回点，

需在指针进栈时同时将一个标志进栈）。

要求实现下列函数：

void PostOrder(BiTree bt, void(*visit)(TElemType));

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild,*rchild;

} BiTNode, *BiTree;

可用栈类型Stack的相关定义：

typedef struct {

BiTNode *ptr; // 二叉树结点的指针类型

int tag; // 0..1

} SElemType; // 栈的元素类型

Status InitStack(Stack &S);

Status StackEmpty(Stack S);

Status Push(Stack &S, SElemType e);

Status Pop(Stack &S, SElemType &e);

Status GetTop(Stack S, SElemType &e);

void PostOrder(BiTree bt, void(*visit)(TElemType))

{Stack S;

InitStack(S);

SElemType p,pt;

p.ptr=bt;

pt.ptr=bt;

p.tag=1;

if(!p.ptr) return;

Push(S,p);

while(!p.tag||!StackEmpty(S))

{

while(p.ptr)

{

while(p.ptr=p.ptr->lchild) {p.tag=0;Push(S,p);}

GetTop(S,p);

if(p.ptr=p.ptr->rchild){p.tag=1;Push(S,p);}

}

Pop(S,p);

visit(p.ptr->data);

pt=p;

Pop(S,p);

while(pt.tag||!p.ptr->rchild)

{visit(p.ptr->data);

pt=p;

if(!StackEmpty(S))Pop(S,p);

else return;

}

if(!pt.tag)

{Push(S,p);

p.ptr=p.ptr->rchild;

p.tag=1;

Push(S,p);

}

}

}

6.41③编写递归算法，在二叉树中求位于先序序列中

第k个位置的结点的值。

要求实现下列函数：

TElemType PreOrder(BiTree bt, int k);

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

TElemType PreOrder(BiTree bt, int k)

{int i=0,count=0; //i为循环变量、count为记录根结点的左子树的结点个数

TElemType T; //定义一个返回值变量T

BiTree a[20],b; //a[20]记录左子树的根结点,b为一个中间变量

if(k <=0||!bt) return '#'; //当k为0或者bt空时，没有找到结点，返回'#'

if(k==1) return bt->data; //当k从给定的数减到1时，表示找到，返回bt->data

T=PreOrder(bt->lchild,k-1); //左子树递归

if(T!='#') //当找到T时，返回T

return(T);

b=bt->lchild; //没有找到，继续找

while(b||i) //下面是计算左子树有多少个结点的算法，并记录在count中

{

if(b) //当左子树非空时，

{

a[i]=b; //记录第i个结点在a[i]中，用来计算本结点的右子树用的

i++; //计算下一个结点的序号

b=b->lchild; //对下一个结点操作

count++; //记录结点数

}

else

{

i--; //如果b空，表示执行到最左的叶子，现在要找到上一个结点的右子树

b=a[i]; //把上一个结点赋给b

b=b->rchild; //使b指向右子树

}

}

T=PreOrder(bt->rchild,k-count-1); //递归右子树,并返回k-count-1，表示要找的结点可能在右子树的第k-count-1的位置

if(T!='#') //对T判断，当T不为'#'时，表示找到，返回T

return (T);

else //否则返回 '#'表示没有找到

return '#';

}

6.42③编写递归算法，计算二叉树中叶子结点的数目。

要求实现下列函数：

void Leaves(BiTree bt, int &x);

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

void Leaves(BiTree bt, int &x)

{ if(!bt) x=0;

elseif(!bt->lchild&&!bt->rchild)

x+=1;

else

{if(bt->lchild) Leaves(bt->lchild,x);

if(bt->rchild) Leaves(bt->rchild,x);

}

}

6.43③ 编写递归算法，将二叉树中所有结点的

左、右子树相互交换。

要求实现下列函数：

void Exchange(BiTree &bt);

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

void Exchange(BiTree &bt)

{ BiTree b;

if(!bt)

return;

else

{

Exchange(bt->lchild);

Exchange(bt->rchild);

b=bt->rchild;

bt->rchild=bt->lchild;

bt->lchild=b;

}

}

6.44④ 编写递归算法：求二叉树中以元素值

为x的结点为根的子树的深度。

要求实现下列函数：

int Depthx(BiTree T, TElemType x);

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

int Depthx(BiTree T, TElemType x)

{ if(T)

if(T->data==x)

if(Depthx(T->lchild,T->lchild->data)>Depthx(T->rchild,T->rchild->data))

returnDepthx(T->lchild,T->lchild->data)+1;

else

returnDepthx(T->rchild,T->rchild->data)+1;

else

{ if(Depthx(T->lchild,x))

return Depthx(T->lchild,x);

else

return Depthx(T->rchild,x);

}

else return 0;

}

6.46③ 编写复制一棵二叉树的非递归算法。

要求实现下列函数：

void CopyBiTree(BiTree T, BiTree &TT);

二叉链表类型定义：

typedef char TElemType; // 设二叉树的元素为char类型

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

可用队列类型Queue的相关定义：

typedef BiTree QElemType; // 设队列元素为二叉树的指针类型

Status InitQueue(Queue &Q);

Status EnQueue(Queue &Q, QElemType e);

Status DeQueue(Queue &Q, QElemType&e);

Status GetHead(Queue Q, QElemType &e);

Status QueueEmpty(Queue Q);

void CopyBiTree(BiTree T, BiTree &TT)

{ Queue Q1,Q2;

BiTNode *p,*q;

InitQueue(Q1);InitQueue(Q2);

if(T){

EnQueue(Q1,T);

TT=(BiTNode*)malloc(sizeof(BiTNode));

EnQueue(Q2,TT);

while(!QueueEmpty(Q1))

{

DeQueue(Q1,p);

DeQueue(Q2,q);

q->data=p->data;

if(p->lchild)

{q->lchild=(BiTNode*)malloc(sizeof(BiTNode));

EnQueue(Q1,p->lchild);

EnQueue(Q2,q->lchild);

}

if(p->rchild)

{q->rchild=(BiTNode*)malloc(sizeof(BiTNode));

EnQueue(Q1,p->rchild);

EnQueue(Q2,q->rchild);

}

}

}

}

6.47④编写按层次顺序(同一层自左至右)遍历二叉树的算法。

要求实现下列函数：

void LevelOrder(BiTree bt, char *ss);

二叉链表类型定义：

typedef char TElemType; // 设二叉树的元素为char类型

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

可用队列类型Queue的相关定义：

typedef BiTree QElemType; // 设队列元素为二叉树的指针类型

Status InitQueue(Queue &Q);

Status EnQueue(Queue &Q, QElemType e);

Status DeQueue(Queue &Q, QElemType&e);

Status GetHead(Queue Q, QElemType &e);

Status QueueEmpty(Queue Q);

提示：可将遍历元素的值（字符）依次置入ss，并最后以'\0'结尾。

也可以用下列字符串函数产生ss：

int sprintf(char *buffer, char *format [,argument, ...]);

char *strcat(char *dest, char *src);

void LevelOrder(BiTree bt, char *ss)

{Queue Q;

BiTNode *t;

char *s=ss;

InitQueue(Q);

if(bt){

EnQueue(Q,bt);

while(!QueueEmpty(Q))

{

DeQueue(Q,t);

*s++=t->data;

if(t->lchild)

EnQueue(Q,t->lchild);

if(t->rchild)

EnQueue(Q,t->rchild);

}

}

*s='\0';

}

void LevelOrder(BiTree bt, char *ss)

{Queue Q;

BiTNode *t;

char *s=ss;

InitQueue(Q);

if(bt){

EnQueue(Q,bt);

while(!QueueEmpty(Q))

{

DeQueue(Q,t);

*s++=t->data;

if(t->lchild)

EnQueue(Q,t->lchild);

if(t->rchild)

EnQueue(Q,t->rchild);

}

}

*s='\0';

}

6.49④编写算法判别给定二叉树是否为完全二叉树。

要求实现下列函数：

Status CompleteBiTree(BiTree bt);

二叉链表类型定义：

typedef struct BiTNode {

TElemType data;

BiTNode *lchild, *rchild;

} BiTNode, *BiTree;

可用队列类型Queue的相关定义：

typedef BiTree QElemType; // 设队列元素为二叉树的指针类型

Status InitQueue(Queue &Q);

Status EnQueue(Queue &Q, QElemType e);

Status DeQueue(Queue &Q, QElemType&e);

Status GetHead(Queue Q, QElemType &e);

Status QueueEmpty(Queue Q);

Status CompleteBiTree(BiTree bt)

{Queue Q;

InitQueue(Q);

BiTree t;

int flag=1;

if(!bt) return TRUE;

EnQueue(Q,bt);

while(!QueueEmpty(Q))

{ DeQueue(Q,t);

if(flag&&t->lchild)EnQueue(Q,t->lchild);

else if(!t->lchild) flag=0;

else return FALSE;

if(flag&&t->rchild)EnQueue(Q,t->rchild);

else if(!t->rchild);

else return FALSE;

}

return TRUE;

}

6.65④ 已知一棵二叉树的前序序列和中序序列分别

存于两个一维数组中，试编写算法建立该二叉树的二

叉链表。

要求实现以下函数：

void BuildBiTree(BiTree &bt, int ps,char *pre,

int is, char *ino,int n);

二叉链表类型定义：

typedef char TElemType;

typedef struct BiTNode {

TElemType data;

BiTNode*lchild, *rchild;

} BiTNode, *BiTree;

void BuildBiTree(BiTree &bt, int ps,char *pre,

int is, char *ino,int n)

{ int i,L,R;

if( !n )

{

bt = NULL;

return ;

}

bt = ( BiTree )malloc( sizeof( BiTNode ) );

bt->data = pre[ps];

for( i = is; ino[i] != pre[ps]; i++ );

L= i - is;

R= n-L-1;

if( L )

BuildBiTree( bt->lchild, ps+1, pre, is, ino, L );

if( R )

BuildBiTree( bt->rchild,ps+L+1,pre, i+1, ino, R );

}

数据结构课后设计题第七章

7.22③试基于图的深度优先搜索策略写一算法，

判别以邻接表方式存储的有向图中是否存在由顶

点vi到顶点vj的路径(i≠j)。 注意：算法中涉及

的图的基本操作必须在此存储结构上实现。

实现下列函数：

Status DfsReachable(ALGraph g, int i, intj);

图的邻接表以及相关类型和辅助变量定义如下：

Status visited[MAX_VERTEX_NUM];

typedef char VertexType;

typedef struct ArcNode {

int adjvex;

struct ArcNode *nextarc;

} ArcNode;

typedef struct VNode {

VertexType data;

ArcNode *firstarc;

} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {

AdjList vertices;

int vexnum, arcnum;

} ALGraph;

Status DfsReachable(ALGraph g, int i, intj)

{if( !g.vexnum || !g.arcnum )return FALSE;

Queue Q;

InitQueue( Q );

EnQueue( Q, i );

int u;

while( ! QueueEmpty ( Q ) )

{

DeQueue( Q, u );

visited[u] = 1;

ArcNode *p;

int k;

for( p = g.vertices[u].firstarc; p; p = p->nextarc )

{

k = p->adjvex;

if( k == j ) return OK;

if( !visited[k] ) EnQueue( Q, k );

}

}

return FALSE;

}

7.23③同7.22题要求。试基于图的广度优先搜索策略写一算法。

实现下列函数：

Status BfsReachable(ALGraph g, int i, intj);

图的邻接表以及相关类型和辅助变量定义如下：

Status visited[MAX_VERTEX_NUM];

typedef char VertexType;

typedef struct ArcNode {

int adjvex;

struct ArcNode *nextarc;

} ArcNode;

typedef struct VNode {

VertexType data;

ArcNode *firstarc;

} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {

AdjList vertices;

int vexnum, arcnum;

} ALGraph;

Status InitQueue(Queue &q);

Status EnQueue(Queue &q, int e);

Status DeQueue(Queue &q, int &e);

Status QueueEmpty(Queue q);

Status GetFront(Queue q, int &e);

Status BfsReachable(ALGraph g, int i, intj)

{ if( !g.vexnum || !g.arcnum ) return FALSE;

Queue Q;

InitQueue( Q );

EnQueue( Q, i );

int u;

while( ! QueueEmpty ( Q ) )

{

DeQueue( Q, u );

visited[u] = 1;

ArcNode *p;

int k;

for( p = g.vertices[u].firstarc; p; p = p->nextarc )

{

k = p->adjvex;

if( k == j ) return OK;

if( !visited[k] ) EnQueue( Q,k );

}

}

return FALSE;

}

7.24③ 试利用栈的基本操作编写，按深度优先搜索策略

遍历一个强连通图的非递归形式的算法。算法中不规定具

体的存储结构，而将图Graph看成是一种抽象的数据类型。

实现下列函数：

void Traverse(Graph dig, VertexType v0,void(*visit)(VertexType));

图以及相关类型、函数和辅助变量定义如下：

Status visited[MAX_VERTEX_NUM];

int LocateVex(Graph g, VertexType v);

VertexType GetVex(Graph g, int i);

int FirstAdjVex(Graph g, int v);

int NextAdjVex(Graph g, int v, int w);

void visit(char v);

Status InitStack(SStack &s);

Status Push(SStack &s, SElemType x);

Status Pop(SStack &s, SElemType&x);

Status StackEmpty(SStack s);

Status GetTop(SStack s, SElemType &e);

void Traverse(Graph dig, VertexType v0, void (*visit)(VertexType))

{int i,v,flag; //flag来记录某点还有没有邻接点

SStack s;

VertexType p;

InitStack( s );

if( dig.vexnum && dig.arcnum )

{

i = LocateVex( dig, v0 );

visited[i] = TRUE;

visit( v0 );

Push( s, v0 );

while( ! StackEmpty( s ) )

{

GetTop( s, p );

v=LocateVex( dig, p );

flag = 0;

for( i = FirstAdjVex( dig, v ); i >= 0; i = NextAdjVex( dig, v, i ) )

{

if( ! visited[i] )

{

p = GetVex(dig,i);

flag = 1;

break;

}

}

if( flag )

{

visit( p );

visited[i] = TRUE;

Push( s, p );

}

else

Pop( s, p );

}

}

}

7.27④ 采用邻接表存储结构，编写一个判别无向图中任意给定的

两个顶点之间是否存在一条长度为k的简单路径的算法。

实现下列函数：

Status SinglePath(ALGraph g, VertexType sv,VertexType tv,

int k, char *sp);

图的邻接表以及相关类型、函数和辅助变量定义如下：

Status visited[MAX_VERTEX_NUM];

typedef char StrARR[100][MAX_VERTEX_NUM+1];

typedef char VertexType;

typedef struct ArcNode {

int adjvex;

struct ArcNode *nextarc;

} ArcNode;

typedef struct VNode {

VertexType data;

ArcNode *firstarc;

} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {

AdjList vertices;

int vexnum, arcnum;

} ALGraph;

int LocateVex(Graph g, VertexType v);

void inpath(char *&path, VertexType v);

void depath(char *&path, VertexType v);

Status SinglePath(ALGraph g, VertexType sv,VertexType tv, int k, char *sp)

{int i,j,l;

ArcNode *p;

if( sv == tv && !k )

{

inpath( sp, tv );

return OK;

}

else

{

i = LocateVex(g,sv);

visited[i] = 1;

inpath( sp, sv );

for( p = g.vertices[i].firstarc; p; p = p->nextarc )

{

l = p->adjvex;

if( !visited[l] )

{

if( SinglePath ( g,g.vertices[l].data, tv, k-1, sp ) )

return OK;

else

depath( sp,g.vertices[l].data );

}

}

visited[i]=0;

}

}

7.28⑤ 已知有向图和图中两个顶点u和v，试编写算法求

有向图中从u到v的所有简单路径。

实现下列函数：

void AllPath(ALGraph g, VertexType sv,VertexType tv,

StrARR &path, int &i);

图的邻接表以及相关类型、函数和辅助变量定义如下：

Status visited[MAX_VERTEX_NUM];

typedef char StrARR[100][MAX_VERTEX_NUM+1];

typedef char VertexType;

typedef struct ArcNode {

int adjvex;

struct ArcNode *nextarc;

} ArcNode;

typedef struct VNode {

VertexType data;

ArcNode *firstarc;

} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {

AdjList vertices;

int vexnum, arcnum;

} ALGraph;

int LocateVex(Graph g, VertexType v);

void inpath(char *path, VertexType v);

void depath(char *path, VertexType v);

void Copy(char* s,char* d,int length)

{

int i;

for(i=0;i<length;i++) d[i] = s[i];

d[i] = '\0';

}

int Find(ALGraph g, int s, int t,char*tempPath,int current,int start,StrARR &path,int &c_path)

{

ArcNode *arc = g.vertices[s].firstarc;

if(arc == NULL) return 0;

while(arc != NULL)

{

if(visited[arc->adjvex] == FALSE)

{

visited[arc->adjvex] = TRUE;

inpath(tempPath,g.vertices[arc->adjvex].data);

if(arc->adjvex == t)

{

Copy(tempPath,path[c_path++],current+1);

}

else

{

Find(g,arc->adjvex,t,tempPath,current+1,start,path,c_path);

}

if(arc->adjvex != start)

{

depath(tempPath,g.vertices[arc->adjvex].data);

visited[arc->adjvex] =FALSE;

}

}

arc = arc->nextarc;

}

return 0;

}

void AllPath(ALGraph g, VertexType sv,VertexType tv,

StrARR &path, int &i)

{

int s = LocateVex(g,sv);

int t = LocateVex(g,tv);

char* tempPath = NULL;

tempPath = (char*)malloc(20);

inpath(tempPath,sv);

visited[s] = TRUE;

Find(g,s,t,tempPath,1,s,path,i);

}

7.29⑤ 试写一个算法，在以邻接矩阵方式存储的

有向图G中求顶点i到顶点j的不含回路的、长度为k

的路径数。

实现下列函数：

int SimplePath(MGraph G, int i, int j, intk);

图的邻接矩阵存储结构的类型定义如下：

typedef enum {DG,DN,AG,AN} GraphKind; // 有向图,有向网,无向图,无向网

typedef struct {

VRType adj; // 顶点关系类型。对无权图，用1(是)或0(否)表示相邻否；

// 对带权图，则为权值类型

InfoType *info; // 该弧相关信息的指针(可无)

}ArcCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct {

AdjMatrix arcs; // 邻接矩阵

VertexType vexs[MAX_VERTEX_NUM]; // 顶点向量

int vexnum,arcnum; // 图的当前顶点数和弧数

GraphKind kind; // 图的种类标志

}MGraph;

int SimplePath(MGraph G, int i, int j, intk)

{int sum = 0,v;

if( G.arcs[i][j].adj && k == 1 && ! visited[j] )

sum = 1;

else

if( k > 1 )

{

visited[i] = 1;

for( v = 0; v < G.vexnum; v++ )

{

if( G.arcs[i][v].adj &&! visited[v] )

sum += SimplePath( G, v,j, k-1 );

}

visited[i] = 0;

}

return sum;

}

7.31③试完成求有向图的强连通分量的算法，并分析算法的时间复杂度。

实现下列函数：

void StronglyConnected(OLGraph dig, StrARR&scc, int &n);

图的十字链表以及相关类型和辅助变量定义如下：

Status visited[MAX_VERTEX_NUM];

int finished[MAX_VERTEX_NUM];

typedef charStrARR[MAX_VERTEX_NUM][MAX_VERTEX_NUM+1]; // 记录各强连通分量

typedef struct ArcBox {

int tailvex,headvex;

struct ArcBox *hlink,*tlink;

} ArcBox;

typedef struct VexNode {

VertexType data;

ArcBox *firstin,*firstout;

} VexNode;

typedef struct {

VexNode xlist[MAX_VERTEX_NUM];

int vexnum, arcnum;

} OLGraph;

void DFS1(OLGraph dig,int nVex,int&count)

{

if(visited[nVex] == TRUE) return;

visited[nVex] = TRUE;

ArcBox *p = dig.xlist[nVex].firstout;

while(p!=NULL)

{

DFS1(dig,p->headvex,count);

p = p->tlink;

}

finished[++count] = nVex;

return;

}

void DFS2(OLGraph dig,int nVex,StrARR&scc,int k,int& j)

{

if(visited[nVex] == TRUE) return;

visited[nVex] = TRUE;

scc[k][j++] = dig.xlist[nVex].data;

ArcBox *p = dig.xlist[nVex].firstin;

while(p!=NULL)

{

DFS2(dig,p->tailvex,scc,k,j);

p = p->hlink;

}

return;

}

void StronglyConnected(OLGraph dig, StrARR&scc, int &n)

{

if(dig.vexnum <= 0) return;

int count = 0;

int i;

for(i=0;i<dig.vexnum;i++)

{

DFS1(dig,i,count);

}

for(i=0;i<dig.vexnum;i++)

visited[i] = FALSE;

int k=0;

int j=0;

for(i=count;i>0;i--)

{

if(visited[finished[i]] == FALSE)

{

DFS2(dig,finished[i],scc,k,j);

scc[k][j] = '\0';

k++;

j=0;

}

}

n=k;

}

数据结构课后设计题第九章

9.26② 试将折半查找算法改写成递归算法。

实现下列函数：

int BinSearch(SSTable s, int low, int high,KeyType k);

静态查找表的类型SSTable定义如下：

typedef struct {

KeyType key;

... ... // 其他数据域

} ElemType;

typedef struct {

ElemType *elem;

int length;

} SSTable;

int BinSearch(SSTable s, int low, int high,KeyType k)

{int mid;

if(low<=high)

{

mid=(low+high)/2;

if(s.elem[mid].key==k) return mid;

if(s.elem[mid].key<k)

return BinSearch(s,mid+1,high,k);

if(s.elem[mid].key>k)

return BinSearch(s,low,high-1,k);

}

return 0;

}

9.31④ 试写一个判别给定二叉树是否为二叉排序树

的算法，设此二叉树以二叉链表作存储结构。且树中

结点的关键字均不同。

实现下列函数：

Status IsBSTree(BiTree t);

二叉树的类型BiTree定义如下：

typedef struct {

KeyType key;

... ... // 其他数据域

} ElemType;

typedef struct BiTNode {

ElemType data;

BiTNode *lchild,*rchild;

}BiTNode, *BiTree;

Status IsBSTree(BiTree t)

{ if( t )//&& ! ( t->lchild ||t->rchild ) )//空树和叶子不用判断

{

if( t->lchild && ( t->data.key <t->lchild->data.key ) )//左孩子不空，左孩子的key比本身的大

return FALSE;

else if( t->rchild && ( t->data.key >t->rchild->data.key ) )//右孩子不空，右孩子的key比本身的大

return FALSE;

else if( !IsBSTree( t->lchild ) )//判断左子树

return FALSE;

else if( !IsBSTree( t->rchild ) )//判断右子树

return FALSE;

}

return TRUE;

}

9.33③编写递归算法，从大到小输出给定二叉排序树

中所有关键字不小于x的数据元素。要求你的算法的时

间复杂度为O(log2n+m)，其中n为排序树中所含结点数，

m为输出的关键字个数。

实现下列函数：

void OrderOut(BiTree t, KeyType x,void(*visit)(TElemType));

二叉树的类型BiTree定义如下：

typedef struct {

KeyType key;

... ... // 其他数据域

} ElemType;

typedef struct BiTNode {

ElemType data;

BiTNode *lchild,*rchild;

}BiTNode, *BiTree;

void OrderOut(BiTree t, KeyType x,void(*visit)(TElemType))

{if(t->rchild) OrderOut(t->rchild,x,visit);

if(t->data.key>=x)

visit(t->data);

if(t->lchild)OrderOut(t->lchild,x,visit);

}

9.44④已知某哈希表的装载因子小于1，哈希函数

H(key)为关键字(标识符)的第一个字母在字母表中

的序号，处理冲突的方法为线性探测开放定址法。

试编写一个按第一个字母的顺序输出哈希表中所有

关键字的算法。

实现下列函数：

void PrintKeys(HashTable ht,void(*print)(StrKeyType));

哈希表的类型HashTable定义如下：

#define SUCCESS 1

#define UNSUCCESS 0

#define DUPLICATE -1

typedef char StrKeyType[4];

typedef struct {

StrKeyType key;

void *any;

} HElemType;

int hashsize[] = { 7,11,17,23,29,37,47 };

typedef struct {

HElemType elem[MAXLEN];

int count;

int sizeindex;

} HashTable;

void PrintKeys(HashTable ht,void(*print)(StrKeyType))

{int index,i;

char ch;

for(i=0; i<26; i++)

{

index = i%hashsize[ht.sizeindex];//index从0开始

ch = ht.elem[index].key[0];

while(ch>='A' && ch<='Z')//若不为空值

{

if(ht.elem[index].key[0]==('A'+i))

(*print)(ht.elem[index].key);

index = (++index)%hashsize[ht.sizeindex];

ch = ht.elem[index].key[0];

}

}

}

9.45③ 假设哈希表长为m，哈希函数为H(x)，用链地址法

处理冲突。试编写输入一组关键字并建造哈希表的算法。

实现下列函数：

int BuildHashTab(ChainHashTab &H, intn, HKeyType es[]);

哈希表的类型ChainHashTab定义如下：

#define NUM 7

#define NULLKEY -1

#define SUCCESS 1

#define UNSUCCESS 0

#define DUPLICATE -1

typedef char HKeyType;

typedef struct HNode {

HKeyType data;

struct HNode* next;

}*HLink;

typedef struct {

HLink *elem; // 指针存储基址，动态分配数组

int count; // 当前表中含有的记录个数

int cursize; // 哈希表的当前容量

}ChainHashTab; // 链地址哈希表

int Hash(ChainHashTab H, HKeyType k) {

// 哈希函数

return k % H.cursize;

}

Status Collision(ChainHashTab H, HLink&p) {

// 求得下一个探查地址p

if(p && p->next) {

p= p->next;

return SUCCESS;

}else return UNSUCCESS;

}

int BuildHashTab(ChainHashTab &H, intn, HKeyType es[])

{

int i = 0,l,flag;

HLink p,node;

while( es[i] )

{

l = Hash( H, es[i] );

node = ( HLink )malloc( sizeof( HNode ) );

node->data = es[i];

node->next = NULL;

i++;

if( !H.elem[l] )

H.elem[l] = node;

else

{

flag = 0;

p = H.elem[l];

if( p->data == node->data )

flag = 1;

while( Collision( H, p ) )

if( p->data ==node->data )

{

flag = 1;

break;

}

if( !flag )

{

p = H.elem[l];

node->next = p;

H.elem[l] = node;

}

}

}

}

数据结构课后设计题第十章

10.23② 试以L.r[k+1]作为监视哨改写教材10.2.1节

中给出的直接插入排序算法。其中，L.r[1..k]为待排

序记录且k<MAXSIZE。

实现下列函数：

void InsertSort(SqList &L);

顺序表的类型SqList定义如下：

typedef struct {

KeyType key;

...

} RedType;

typedef struct {

RedType r[MAXSIZE+1]; // r[0]闲置或用作哨兵单元

int length;

} SqList;

void InsertSort(SqList &L)

{ int i,j,k;

for(i=2; i<=L.length; i++)

{

L.r[0] = L.r[i];

int j;

for(j=i-1; j>0; j--)

if(L.r[i].key>=L.r[j].key)

break;

for(k=i-1; k>=j+1; k--)

L.r[k+1] = L.r[k];

L.r[j+1] = L.r[0];

}

}

10.26② 如下所述改写教科书1.4.3节中的起泡排序算法：

将算法中用以起控制作用的布尔变量change改为一个整型变

量，指示每一趟排序中进行交换的最后一个记录的位置，并

以它作为下一趟起泡排序循环终止的控制值。

实现下列函数：

void BubbleSort(SqList &L);

顺序表的类型SqList定义如下：

typedef struct {

KeyType key;

...

} RedType;

typedef struct {

RedType r[MAXSIZE+1]; // r[0]闲置或用作哨兵单元

int length;

} SqList;

比较函数和交换函数:

Status LT(RedType a, RedType b); // 比较函数："<"

Status GT(RedType a, RedType b); // 比较函数：">"

void Swap(RedType &a, RedType &b);// 交换函数

void BubbleSort(SqList &L)

{int i, j, change = 1;

for( i = L.length; i > 1; i = change )

for( change = 1, j = 1; j < i; j++ )

if( GT( L.r[j], L.r[j+1] ) )

{

Swap(L.r[j],L.r[j+1]);

change = j;

}

}

10.32⑤荷兰国旗问题：设有一个仅由红、白、兰

这三种颜色的条块组成的条块序列。请编写一个时

间复杂度为O(n)的算法，使得这些条块按红、白、

兰的顺序排好，即排成荷兰国旗图案。

实现下列函数：

void HFlag(FlagList &f)

"荷兰国旗"的顺序表的类型FlagList定义如下：

#define red '0'

#define white '1'

#define blue '2'

typedef char ColorType;

typedef struct {

ColorType r[MAX_LENGTH+1];

int length;

} FlagList;

void HFlag(FlagList &f)

{int i = 1, j =1, k = f.length;

while( j <= k )

switch( f.r[j] )

{

case red:

swap( f.r[i++], f.r[j++] );

break;

case white:

j++;

break;

case blue:

swap( f.r[j], f.r[k] );

k--;

}

}

10.34③已知(k1,k2,...,kp)是堆，则可以写一个时

间复杂度为O(log(n))的算法将(k1,k2,...,kp,kp+1)

调整为堆。试编写"从p=1起，逐个插入建堆"的算法，

并讨论由此方法建堆的时间复杂度。

实现下列函数：

void CreateHeap(HeapType &h, char *s);

堆（顺序表）的类型HeapType定义如下：

typedef char KeyType;

typedef struct {

KeyType key;

... ...

} RedType;

typedef struct {

RedType r[MAXSIZE+1];

int length;

} SqList, HeapType;

void CreateHeap(HeapType &h, char *s)

{int j,k,i;

i= -1;

while( s[++i] )

{

h.r[i+1].key = s[i];

h.length++;

}

for( i = 2; i <= h.length; i++ )

{

j = i;

while( j != 1 ) //把H.r[i]插入

{

k = j / 2;

if( LT(h.r[j], h.r[k] ) )

swap( h.r[j], h.r[k] );

j = k;

}

}

}

10.42④序列的"中值记录"指的是：如果将此序列排序

后，它是第n/2个记录。试写一个求中值记录的算法。

实现下列函数：

KeyType MidElement(SqList &L);

顺序表的类型SqList定义如下：

typedef struct {

KeyType key;

...

} RedType;

typedef struct {

RedType r[MAXSIZE+1]; // r[0]闲置或用作哨兵单元

int length;

} SqList;

KeyType MidElement(SqList &L)

{int i,j,k;

intmid=(1+L.length)/2;

k=L.length;

if(k==0) return '#';

for(i=k-1;i>=1;i--)

if(L.r[i].key>L.r[i+1].key)

{L.r[k+1]=L.r[i];

L.r[i]=L.r[i+1];

for(j=i+1;L.r[k+1].key>L.r[j].key;++j) L.r[j-1]=L.r[j];

L.r[j-1]=L.r[k+1];

}

return L.r[mid].key;

}

10.43③已知记录序列a[1..n] 中的关键字各不相同，

可按如下所述实现计数排序：另设数组c[1..n]，对每

个记录a[i]， 统计序列中关键字比它小的记录个数存

于c[i]， 则c[i]=0的记录必为关键字最小的记录，然

后依c[i]值的大小对a中记录进行重新排列，试编写算

法实现上述排序方法。

实现下列函数：

void CountSort(SqList &L);

顺序表的类型SqList定义如下：

typedef struct {

KeyType key;

...

} RedType;

typedef struct {

RedType r[MAXSIZE+1]; // r[0]闲置或用作哨兵单元

int length;

} SqList;

void CountSort(SqList &L)

{

int i, j, count, min, t;

int c[50];

for( i = 1;i <= L.length; i++ )

{

for( j = 1, count = 0; j <= L.length; j++ )

if( LT(L.r[j], L.r[i] ) )

count++;

c[i] = count;

}

for( i = 1;i <= L.length; i++ )

{

min = i;

for( j = i+1;j <= L.length; j++ )

if( c[j]<c[min] )

min = j;

Swap( L.r[i], L.r[min] );

t = c[i];

c[i] = c[min];

c[min] = t;

}

}