实验一 链表
#include <stdio.h>
#include <stdlib.h>
#define ERROR NULL
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data;
PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
List CreateFromTail() /*尾插法建表*/
{
List L; Position r, s; int c; int flag =1;
L=(List)malloc(sizeof(struct LNode));//为头结点分配存储空间
L->Next=NULL; r=L; //r指针始终动态指向链表的当前表尾
printf("请输入整数,以0结束:");
while(flag)
//flag为标志,初值为1。输入“$”时flag为0,建表结束
{
scanf("%d",&c);
if(c!=0)
{
s=(Position)malloc(sizeof(struct LNode)); s->Data=c;
r->Next=s;
r=s;
}
else
{
flag=0;
r->Next=NULL;
}
}
return L;
}
/*ElementType FindKth( List L, int K )
{ //根据指定的位序K,返回L中相应元素
Position p;
int cnt = 1; //位序从1开始
p = L->Next; //p指向L的第1个结点
while ( p && cnt<K ) {
p = p->Next;
cnt++;
}
if ( (cnt==K) && p )
return p->Data; //找到第K个
else
return ERROR; //否则返回错误信息
}*/
Position FindKth( List L, int K )
{ //根据指定的位序K,返回L中相应元素
Position p;
int cnt = 1; //位序从1开始
p = L->Next; //p指向L的第1个结点
while ( p && cnt<K ) {
p = p->Next;
cnt++;
}
if (cnt==K)
return p; //找到第K个
else
return ERROR; //否则返回错误信息
}
Position Find( List L, ElementType X )
{
Position p = L; /* p指向L的第1个结点 */
while ( p && p->Data!=X )
p = p->Next;
/* 下列语句可以用 return p; 替换 */
if ( p )
return p;
else
return ERROR;
}
void PrintLL (List L)
{
Position p;
p = L->Next;
printf("链表结点数据为:");
while(p!=NULL)
{
printf("%d ",p->Data);
p=p->Next;
}
printf("\n");
}
bool Insert( List L, ElementType X, int i )
{ /* 这里默认L有头结点 */
Position tmp, pre;
int cnt = 0;
/* 查找位序为i-1的结点 */
pre = L; /* pre指向表头 */
while ( pre && cnt<i-1 ) {
pre = pre->Next;
cnt++;
}
if ( pre==NULL ) { /* 所找结点不在L中 */
printf("插入位置参数错误\n");
return false;
}
else { /* 找到了待插结点的前一个结点pre;若i为1,pre就指向表头 */
/* 插入新结点 */
tmp=(Position)malloc(sizeof(struct LNode)); /*申请、填装结点*/
tmp->Data = X;
tmp->Next = pre->Next;
pre->Next = tmp;
return true;
}
}
bool Delete( List L, int i )
{ /* 这里默认L有头结点 */
Position tmp, pre;
int cnt = 0;
/* 查找位序为i-1的结点 */
pre = L; /* pre指向表头 */
while ( pre->Next!=NULL && cnt<i-1 ) {
pre = pre->Next;
cnt++;
}
if (pre->Next==NULL) {
/* 所找结点或位序为i的结点不在L中 */
printf("插入位置参数错误\n");
return false;
} else { /* 找到了待删结点的前一个结点pre */
/* 将结点删除 */
tmp=pre->Next;
pre->Next=tmp->Next;
free(tmp);
return true;
}
}
int main()
{
List l;
Position p;
ElementType e;
int k;
l=CreateFromTail();
PrintLL (l);
printf("请输入要查询第几个结点:");
scanf("%d",&k);
p=FindKth(l, k );
if(p==ERROR)
printf("第%d个结点不存在",k);
else
printf("第%d个结点的值为:%d\n",k,p->Data);
printf("请输入要查找的元素值:\n");
scanf("%d",&e);
p=Find(l,e);
if(p == ERROR)
printf("在此线性表中没有该元素!\n");
else
printf("元素%d在链表中!\n",e);
printf("请输入要插入的位置:\n");
scanf("%d",&k);
printf("请输入要插入的元素值:\n");
scanf("%d",&e);
Insert(l,e,k);
printf("线性表中各元素的值为:\n");
PrintLL (l);
printf("请输入要删除的位置:\n");
scanf("%d",&k);
Delete(l,k);
PrintLL (l);
return 0;
}
实验二 顺序表
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 1000
#define ElementType int
#define ERROR -1
typedef int Position;
typedef struct LNode *PtrToLNode;
struct LNode {
ElementType Data[MAXSIZE];
Position Last;
};
typedef PtrToLNode List;
List MakeEmpty()
{
List L;
L = (List)malloc(sizeof(struct LNode));
L->Last = -1;
return L;
}
void Print(List L)
{
Position i;
for(i=0; i<=L->Last; i++)
{
printf("%d ",L->Data[i]);
}
printf("\n");
}
bool Insert( List L, ElementType X )
{ /* 在L中插入一个新元素X后仍保持正序 */
Position i=0,j;
if ( L->Last == MAXSIZE-1) {
/* 表空间已满,不能插入 */
printf("表满");
return false;
}
while(L->Data[i]<X&&i<=L->Last)
i++;
for( j=L->Last; j>=i; j-- ) /*Last指向序列最后元素 */
L->Data[j+1] = L->Data[j]; /* 将位序i及以后的元素顺序向后移动 */
L->Data[i] = X; /* 新元素插入第i位序 */
L->Last++; /* Last仍指向最后元素 */
return true;
}
void Make(List L)
{
int i,len;
ElementType q;
printf("请输入线性表的长度:");
scanf("%d",&len);
printf("请输入线性表的各元素值:\n");
scanf("%d",&L->Data[0]);
L->Last = 0;
//printf("线性表中各元素的值为:\n");
// Print(L);
for(i=1; i<len; i++)
{
scanf("%d",&q);
Insert(L,q);
// printf("线性表中各元素的值为:\n");
// Print(L);
}
}
Position Find( List L, ElementType X )
{
Position i = 0;
while( i <= L->Last && L->Data[i]!= X )
i++;
if ( i > L->Last ) return ERROR; /* 如果没找到,返回错误信息 */
else return i; /* 找到后返回的是存储位置 */
}
bool Delete( List L, int i )
{ /* 从L中删除指定位序i的元素,该元素数组下标为i-1 */
Position j;
for( j=i; j<=L->Last; j++ )
L->Data[j-1] = L->Data[j]; /*将位序i+1及以后的元素顺序向前移动*/
L->Last--; /* Last仍指向最后元素 */
return true;
}
int main()
{
List l;
ElementType q;
Position p;
l=MakeEmpty();
Make(l);
printf("线性表中各元素的值为:\n");
Print(l);
printf("请输入要插入的元素值:\n");
scanf("%d",&q);
Insert(l,q);
printf("线性表中各元素的值为:\n");
Print(l);
printf("请输入要查找的元素值:\n");
scanf("%d",&q);
p=Find(l,q);
if(p == ERROR)
printf("在此线性表中没有该元素!\n");
else
{
printf("该元素在线性表中的位置为:%d\n",p+1);
Delete(l,p+1);
printf("删除元素%d后,线性表中各元素的值为:\n",q);
Print(l);
}
return 0;
}
实验三括号匹配
#include <stdio.h>
#include <stdlib.h>
#define ElementType char
#define MaxSize 50
/*顺序栈*/
typedef struct SNode
{
ElementType Data[MaxSize]; /*用来存放栈中元素的一维数组*/
int Top; /*用来存放栈顶元素的下标,top为-1表示空栈*/
}*Stack;
/*初始化*/
Stack CreateStack()
{
Stack S = (Stack)malloc(sizeof(struct SNode));
S->Top = -1;
return S;
}
/*判栈满*/
bool IsFull( Stack S )
{
return (S->Top == MaxSize-1);
}
/*入栈*/
bool Push( Stack S, ElementType X )
{
if ( IsFull(S) ) {
printf("堆栈满");
return false;
}
else {
S->Data[++(S->Top)] = X;
return true;
}
}
/*判栈空*/
bool IsEmpty( Stack S )
{
return (S->Top == -1);
}
/*出栈*/
bool Pop( Stack S, ElementType *x )
{
if ( IsEmpty(S) ) {
printf("堆栈空");
return false; /* ERROR是ElementType的特殊值,标志错误 */
}
else
{
*x=S->Data[S->Top];
(S->Top)--;
return true;
}
}
/*取栈顶元素。*/
bool GetTop(Stack S,ElementType *x)
{
/* 将栈S的栈顶元素弹出,放到x所指的存储空间中,但栈顶指针保持不变 */
if(S->Top == -1) /*栈为空*/
return false;
else
{
*x = S->Data[S->Top];
return true;
}
}
/*进行匹配*/
bool Match(char ch,char str)
{
if(ch=='(' && str==')')
{
return true;
}
else if(ch=='[' && str==']')
{
return true;
}
else if(ch=='{' && str=='}')
{
return true;
}
else
return false;
}
void BracketMatch(char *str) /* str[]中为输入的字符串,利用堆栈技术来检查该字符串中的括号是否匹配*/
{
Stack S;
int i;
char ch;
S=CreateStack();
for(i=0; str[i]!='\0'; i++) /*对字符串中的字符逐一扫描*/
{
switch(str[i])
{
case '(':
case '[':
case '{':
Push(S,str[i]);
break;
case ')':
case ']':
case '}':
if(IsEmpty(S))
{
printf("\n右括号多余!");
return;
}
else
{
GetTop(S,&ch);
if(Match(ch,str[i])) /*用Match判断两个括号是否匹配*/
Pop(S,&ch); /*已匹配的左括号出栈*/
else
{
printf("\n对应的左右括号不同类!");
return;
}
}
}/*switch*/
}/*for*/
if(IsEmpty(S))
printf("\n括号匹配!");
else
printf("\n左括号多余!");
}
int main()
{
char str[100];
printf("请输入括号:\n");
gets(str);
BracketMatch(str);
return 0;
}
实验四 多项式的加法
#include <stdio.h>
#include <stdlib.h>
typedef struct Polynode
{
int coef;
int exp;
Polynode *next;
}Polynode, *Polylist;
void polycreate(Polylist head)
{
Polynode *rear, *s;
int c,e;
rear=head; /* rear 始终指向单链表的尾,便于尾插法建表*/
scanf("%d,%d",&c,&e); /*键入多项式的系数和指数项*/
while(c!=0) /*若c=0,则代表多项式的输入结束*/
{
s=(Polynode*)malloc(sizeof(Polynode)); /*申请新的结点*/
s->coef=c;
s->exp=e;
rear->next=s; /*在当前表尾做插入*/
rear=s;
scanf("%d,%d",&c,&e);
}
rear->next=NULL; /*将表的最后一个结点的next置NULL,以示表结束*/
}
void polyadd(Polylist polya, Polylist polyb)
/*此函数用于将两个多项式相加,然后将和多项式存放在多项式polya中,并将多项式ployb删除*/
{
Polynode *p, *q, *r, *temp;
int sum;
p=polya->next; /*令 p和q分别指向polya和polyb多项式链表中的第一个结点*/
q=polyb->next;
r=polya; /* r指向和多项式的尾结点*/
while (p!=NULL && q!=NULL) /*当两个多项式均未扫描结束时*/
{
if (p->exp < q->exp)
/*如果p指向的多项式项的指数小于q的指数,将p结点加入到和多项式中*/
{
r->next=p;
r=p;
p=p->next;
}
else
if ( p->exp == q->exp) /*若指数相等,则相应的系数相加*/
{
sum=p->coef + q->coef;
if (sum != 0)
{
p->coef=sum;
r->next=p;
r=p;
p=p->next;
temp=q;
q=q->next;
free(temp);
}
else
{
temp=p;
p=p->next;
free(temp);
/*若系数和为零,则删除结点p与q,并将指针指向下一个结点*/
temp=q;
q=q->next;
free(temp);
}
}
else
{
r->next=q;
r=q; /*将q结点加入到和多项式中*/
q = q->next;
}
}
if(p!=NULL) /*多项式A中还有剩余,则将剩余的结点加入到和多项式中*/
r->next=p;
else /*否则,将B中的结点加入到和多项式中*/
r->next=q;
}
void polyprint(Polylist poly)
{
Polynode *p;
p = poly->next;
if(p!=NULL)
{
if(p->coef==1)
printf("x^%d",p->exp);
else if(p->coef==-1)
printf("-x^%d",p->exp);
else
printf("%dx^%d",p->coef,p->exp);
p=p->next;
}
while(p!=NULL)
{
if(p->coef>0)
{
if(p->coef==1)
printf("+x^%d",p->exp);
else
printf("+%dx^%d",p->coef,p->exp);
}
else
{
if(p->coef==-1)
printf("-x^%d",p->exp);
else
printf("%dx^%d",p->coef,p->exp);
}
p=p->next;
}
}
int main()
{
Polylist polya,polyb;
printf("请输入数据建立多项式A:(以0,0结束!)\n");
polya=(Polynode *)malloc(sizeof(Polynode));
polycreate(polya);
printf("P(A)=");
polyprint(polya);
printf("\n请输入数据建立多项式B:(以0,0结束!)\n");
polyb=(Polynode *)malloc(sizeof(Polynode));
polycreate(polyb);
printf("P(B)=");
polyprint(polyb);
polyadd(polya,polyb);
printf("\n相加后的多项式为:\n");
printf("P(C)=");
polyprint(polya);
return 0;
}
实验五 二叉树的遍历
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 50
#define ERROR NULL
typedef char ElementType;
typedef struct TNode *Position;
typedef Position BinTree; /* 二叉树类型 */
struct TNode{ /* 树结点定义 */
ElementType Data; /* 结点数据 */
BinTree Left; /* 指向左子树 */
BinTree Right; /* 指向右子树 */
};
typedef BinTree ElemType;
typedef struct QNode *PtrToQNode;
struct QNode {
ElemType Data[MaxSize]; /* 存储元素的数组 */
int Front, Rear; /* 队列的头、尾指针 */
};
typedef PtrToQNode Queue;
BinTree CreateBinTree()
{
BinTree bt;
char ch;
ch=getchar();
if(ch=='|')
bt=NULL;
else
{
bt=(BinTree)malloc(sizeof(struct TNode));
bt->Data=ch;
bt->Left=CreateBinTree();
bt->Right=CreateBinTree();
}
return bt;
}
void PreorderTraversal( BinTree BT )
{
if( BT ) {
printf("%c ", BT->Data );
PreorderTraversal( BT->Left );
PreorderTraversal( BT->Right );
}
}
void InorderTraversal( BinTree BT )
{
if( BT ) {
InorderTraversal( BT->Left );
printf("%c ", BT->Data); /* 假设数据为整型 */
InorderTraversal( BT->Right );
}
}
void PostorderTraversal( BinTree BT )
{
if( BT ) {
PostorderTraversal( BT->Left );
PostorderTraversal( BT->Right );
printf("%c ", BT->Data);
}
}
Queue CreateQueue()
{
Queue Q = (Queue)malloc(sizeof(struct QNode));
Q->Front = Q->Rear = 0;
return Q;
}
bool IsFull( Queue Q )
{
return ((Q->Rear+1)%MaxSize == Q->Front);
}
bool AddQ( Queue Q, ElemType X )
{
if ( IsFull(Q) ) {
printf("队列满");
return false;
}
else {
Q->Rear = (Q->Rear+1)%MaxSize;
Q->Data[Q->Rear] = X;
return true;
}
}
bool IsEmpty( Queue Q )
{
return (Q->Front == Q->Rear);
}
ElemType DeleteQ( Queue Q )
{
if ( IsEmpty(Q) ) {
printf("队列空");
return ERROR;
}
else {
Q->Front =(Q->Front+1)%MaxSize;
return Q->Data[Q->Front];
}
}
void LevelorderTraversal ( BinTree BT )
{
Queue Q;
BinTree T;
if ( !BT ) return; /* 若是空树则直接返回 */
Q = CreateQueue(); /* 创建空队列Q */
AddQ( Q, BT );
while ( !IsEmpty(Q) ) {
T = DeleteQ( Q );
printf("%c ", T->Data); /* 访问取出队列的结点 */
if ( T->Left ) AddQ( Q, T->Left );
if ( T->Right ) AddQ( Q, T->Right );
}
}
int main()
{
BinTree T;
printf("请按照先序输入节点,空节点请用‘|’代替\n");
T=CreateBinTree();
printf("\n按先序遍历输出:\n");
PreorderTraversal(T);
printf("\n按中序遍历输出:\n");
InorderTraversal(T);
printf("\n按后序遍历输出:\n");
PostorderTraversal(T);
printf("\n按层序遍历输出:\n");
LevelorderTraversal(T);
printf("\n");
return 0;
}
实验六 数表的查找
#include <stdio.h>
#include <stdlib.h>
#define ENDKEY 0
typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree; /* 二叉树类型 */
struct TNode{ /* 树结点定义 */
ElementType Data; /* 结点数据 */
BinTree Left; /* 指向左子树 */
BinTree Right; /* 指向右子树 */
};
BinTree Insert( BinTree BST, ElementType X )
{
if( !BST ){ /* 若原树为空,生成并返回一个结点的二叉搜索树 */
BST = (BinTree)malloc(sizeof(struct TNode));
BST->Data = X;
BST->Left = BST->Right = NULL;
}
else { /* 开始找要插入元素的位置 */
if( X < BST->Data )
BST->Left = Insert( BST->Left, X ); /*递归插入左子树*/
else if( X > BST->Data )
BST->Right = Insert( BST->Right, X ); /*递归插入右子树*/
/* else X已经存在,什么都不做 */
}
return BST;
}
BinTree CreateBST()
/*从键盘输入元素的值,创建相应的二叉排序树*/
{
BinTree bst;
ElementType key;
bst=NULL;
scanf("%d", &key);
while (key!=ENDKEY) /*ENDKEY为自定义常量*/
{
bst=Insert(bst, key);
scanf("%d", &key);
}
return bst;
}
void InorderTraversal( BinTree BT )
{
if( BT ) {
InorderTraversal( BT->Left );
printf("%d ", BT->Data); /* 假设数据为整型 */
InorderTraversal( BT->Right );
}
}
Position FindMax( BinTree BST )
{
if( BST )
while( BST->Right )
BST = BST->Right; /* 沿右分支一直向下,直到最右端点 */
return BST;
}
Position FindMin( BinTree BST )
{ /* 最小元素在最左端点 */
if( !BST ) return NULL; /* 空的二叉搜索树,返回NULL */
else if( !BST->Left ) return BST; /* 找到最左端点并返回 */
else return FindMin( BST->Left ); /* 沿左分支递归查找 */
}
Position Find( BinTree BST, ElementType X )
{
while( BST ) {
if( X > BST->Data )
BST = BST->Right; /* 向右子树中移动,继续查找 */
else if( X < BST->Data )
BST = BST->Left; /* 向左子树中移动,继续查找 */
else /* X == BST->Data */
break; /* 在当前结点查找成功,跳出循环 */
}
return BST; /* 返回找到的结点地址,或是NULL */
}
int main()
{
BinTree T;
int k;
BinTree result;
printf("建立二叉排序树,请输入序列(0结束):\n");
T=CreateBST();
printf("中序遍历输出序列为:");
InorderTraversal(T);
result = FindMax(T);
printf("\n此二叉排序树中的最大值为:%d\n",result->Data);
result = FindMin(T);
printf("此二叉排序树中的最小值为:%d\n",result->Data);
printf("\n请输入要查找的元素:");
scanf("%d",&k);
result = Find(T,k);
if (result != NULL)
printf("要查找的元素%d在二叉排序树中!\n",result->Data);
else
printf("未找到!\n");
return 0;
}
实验七 图及其遍历
#include "stdlib.h"
#include "stdio.h"
#define MAX_VERTEX_NUM 10 /*最多顶点个数*/
#define INFINITY 32768 /*表示极大值,即∞*/
#define True 1
#define False 0
#define Error -1
#define Ok 1
typedef enum{DG, DN, UDG, UDN} GraphKind; /*图的种类:DG表示有向图, DN表示有向网, UDG表示无向图, UDN表示无向网*/
typedef char VertexData; /*假设顶点数据为字符型*/
typedef struct ArcNode
{
int adj; /*对于无权图,用1或0表示是否相邻;对带权图,则为权值类型*/
} ArcNode;
typedef struct
{
VertexData vexs[MAX_VERTEX_NUM]; /*顶点向量*/
ArcNode arcs[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; /*邻接矩阵*/
int vexnum,arcnum; /*图的顶点数和弧数*/
GraphKind kind; /*图的种类标志*/
}AdjMatrix; /*(Adjacency Matrix Graph)*/
typedef struct Node
{
int data;
struct Node *next;
}LinkQueueNode;
typedef struct
{
LinkQueueNode *front;
LinkQueueNode *rear;
}LinkQueue;
int InitQueue(LinkQueue *Q)
{
Q->front=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));
if(Q->front!=NULL)
{
Q->rear=Q->front;
Q->front->next=NULL;
return(True);
}
else
return(False);
}
int EnterQueue(LinkQueue *Q,int x)
{
LinkQueueNode *NewNode;
NewNode=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));
if(NewNode!=NULL)
{
NewNode->data=x;
NewNode->next=NULL;
Q->rear->next=NewNode;
Q->rear=NewNode;
return(True);
}
else
return(False);
}
int DeleteQueue(LinkQueue *Q,int *x)
{
LinkQueueNode *p;
if(Q->front==Q->rear)
return(False);
p=Q->front->next;
Q->front->next=p->next;
if(Q->rear==p)
Q->rear=Q->front;
*x=p->data;
free(p);
return(True);
}
int IsEmpty(LinkQueue *Q)
{
if(Q->front==Q->rear)
return(True);
else
return(False);
}
int LocateVertex(AdjMatrix *G,VertexData v) /*求顶点位置函数*/
{
int j=Error,k;
for(k=0;k<G->vexnum;k++)
if(G->vexs[k]==v)
{
j=k;
break;
}
return(j);
}
void CreateUDG(AdjMatrix *G) /*创建一个无向图*/
{
int i,j,k;
VertexData v1,v2;
printf("输入图的边数,顶点数:\n");
fflush(stdin);
scanf("%d,%d",&G->arcnum,&G->vexnum); /*输入图的顶点数和弧数*/
for(i=0;i<G->vexnum;i++) /*初始化邻接矩阵*/
for(j=0;j<G->vexnum;j++)
G->arcs[i][j].adj=0;
for(i=0;i<G->vexnum;i++)
{
printf("输入图的顶点:\n");
fflush(stdin);
scanf("%c",&G->vexs[i]); /* 输入图的顶点*/
}
for(k=0;k<G->arcnum;k++)
{
printf("输入一条边的两个顶点:\n");
fflush(stdin);
scanf("%c,%c",&v1,&v2);/*输入一条弧的两个顶点及权值*/
i=LocateVertex(G,v1);
j=LocateVertex(G,v2);
G->arcs[i][j].adj=1; G->arcs[j][i].adj=1; /*建立两条边*/
}
}
void output(AdjMatrix *G)
{
int i,j,k=1;
printf("输出图的顶点:\n");
for(i=0;i<G->vexnum;i++)
printf("%c ",G->vexs[i]);
printf("\n输出图的边:\n");
for(i=0;i<G->vexnum;i++)
for(j=i;j<G->vexnum;j++)
{
if(G->arcs[i][j].adj==1)
{
printf("第%d条边为:%c--%c \n",k,G->vexs[i],G->vexs[j]);
k++;
}
}
}
int visited[MAX_VERTEX_NUM];
void DFS(AdjMatrix g, int v0)
/* 图g 为邻接矩阵类型AdjMatrix */
{
int vj;
printf("%c ",g.vexs[v0]);
/*visit(v0);*/
visited[v0]=True;
for ( vj=0;vj<g.vexnum;vj++)
if (!visited[vj] && g.arcs[v0][vj].adj==1)
DFS(g,vj);
}
void TraverseGraph1 (AdjMatrix g)
/*对图g进行深度优先搜索遍历,Graph 表示图的一种存储结构,如数组表示法或邻接表等*/
{
int vi;
for (vi=0;vi<g.vexnum;vi++) /*访问标志数组初始化*/
visited[vi]=False ;
for( vi=0;vi<g.vexnum;vi++) /*调用深度优先遍历连通子图的操作。若图g是连通图,则此DFS只执行一次*/
if (!visited[vi] )
DFS (g,vi);
}
void BFS(AdjMatrix g, int v0)
/* 图g 为邻接矩阵类型AdjMatrix */
{
int vi,vj;
LinkQueue Q;
InitQueue(&Q); /*初始化空队*/
visited[v0]=True;
EnterQueue(&Q,v0);/* v0进队*/
while (!IsEmpty(&Q))
{
DeleteQueue(&Q, &vi); /*队头元素出队*/
printf("%c ",g.vexs[vi]);
for ( vj=0;vj<g.vexnum;vj++)
if (!visited[vj] && g.arcs[vi][vj].adj==1)
{
visited[vj]=True;
EnterQueue(&Q, vj);
}
}
}
void TraverseGraph2 (AdjMatrix g)
/*对图g进行广度优先搜索遍历,Graph 表示图的一种存储结构,如数组表示法或邻接表等*/
{
int vi;
for (vi=0;vi<g.vexnum;vi++) /*访问标志数组初始化*/
visited[vi]=False ;
for( vi=0;vi<g.vexnum;vi++) /*调用广度优先遍历连通子图的操作。若图g是连通图,则此BFS只执行一次*/
if (!visited[vi] )
BFS (g,vi);
}
void main()
{
AdjMatrix G;
CreateUDG(&G);
output(&G);
printf("深度优先遍历序列为:\n");
TraverseGraph1(G);
printf("\n广度优先遍历序列为:\n");
TraverseGraph2(G);
}
`