数据结构实验指导书

实验一顺序表操作实验二栈和队列

实验三栈

实验四二叉树的操作实验五图的遍历操作实验六数据查找

实验七哈希表设计

实验八排序

实验一顺序表操作

一、实验目的

1．熟悉C语言的上机环境，掌握C语言的基本结构。

2．会定义线性表的顺序存储结构。

3．熟悉对顺序表的一些基本操作和具体的函数定义。

二、实验要求

1．认真阅读和掌握本实验内容所给的全部程序。

2．保存和打印出程序运行结果，并结合程序进行分析。

注意事项

在做第一次“数据结构”课程实验之前，要在硬盘（e:\）上建立好自己的工作目录，专门来存储你所做的实验程序及相关信息，以后每次做实验都采用这个目录。

三、实验内容

a.以输入整形数据为主，输入后按“？”结束输入。

b.程序所能表达到的功能为：实现顺序表的创建、查找、插入、删除等功能。

c.程序运行后，输入数据并执行。

#include "stdio.h"

#include "conio.h"

#define MaxSize 50

typedef char elemtype;

typedef struct node

{

elemtype data[MaxSize];

int len;

}lnode,*List;

void init(List L)//创建链表

{ L->len=0;}

int length(List L)//获得链表长度

{ return L->len;}

elemtype getnode(List L,int pos)//返回指定元素

{

if(pos<1 || pos>L->len) printf("error");

else return L->data[pos-1];

}

int locate(List L,elemtype x)//返回所找元素位置

{ int i=0;

while(ilen && L->data[i]!=x) i++;

if(i==L->len) return -1;

else return(i+1);

}

void insert(List L,int pos,elemtype x)//在指定位置插入元素

{ int j;

if(pos<1 || pos>L->len+1) printf("insert error\n");

else {

L->len++;

for(j=L->len;j>=pos;j--) L->data[j]=L->data[j-1];

L->data[pos-1]=x; };

}

void delnode(List L,int pos)//删除指定位置元素

{ int j;

if(pos<1 ||pos>L->len)printf("del error\n");

else {

for(j=pos;jlen;j++)

L->data[j-1]=L->data[j];

L->len--;}

}

void print(List L)//打印元素

{ int i;

for(i=1;ilen;i++)

printf("%c->",L->data[i-1]);

printf("%c",L->data[L->len-1]);

}

main()

{

int i=1,n;

lnode L;

char ch,x;

init(&L);

printf("\n\n\n*******************************顺序表演示程序***********\n"); printf("请输入你想建立的顺序表的元素，以？结束:");

ch=getchar();

while(ch!='?')

{insert(&L,i,ch);

i++;

ch=getchar();

};

printf("你建立的顺序表为:");

print(&L);

printf("\n顺序表的长度为:%d",L.len);

printf("\n输入你想查找的元素：");

fflush(stdin);

scanf("%c",&x);

printf("你查找的元素为%c序位为%d",x,locate(&L,x));

printf("\n输入你想查找的元素序位:");

scanf("%d",&n);

printf("\n你查找的元素为：%c",getnode(&L,n));

printf("\n输入你想插入的元素以及序位:<用逗号隔开>");

fflush(stdin);

scanf("%c,%d",&x,&n);

insert(&L,n,x);

printf("\n插入后顺序表为：");

print(&L);

fflush(stdin);

printf("\n请输入你想删除的元素序位：");

scanf("%d",&n);

delnode(&L,n);

printf("\n删除后的顺序表为：");

print(&L);

getch();

}

四、测试结果

运行程序，屏幕显示：“请输入你想建立的顺序表的元素，以？结束:”输入：54381

你建立的顺序表为:5—>4—>3—>8—>1

顺序表的长度为:5

输入你想查找的元素：4

你查找的元素为4序位为2

输入你想查找的元素序位:4

你查找的元素为：8

输入你想插入的元素以及序位:<用逗号隔开>"：6，3

插入后顺序表为：5—>4—>6—>3—>8—>1

请输入你想删除的元素序位：5

删除后的顺序表为：5—>4—>6—>3—>1

实验二栈和队列

一、实验目的：

1、掌握队列和栈的顺序存储结构和链式结构，以便在实际背景下灵活运

用。

2、掌握栈和队列的特点，即先进后出与先进先出的原则。

二、实验内容：停车场管理

[问题描述]

设有一个可以停放N辆汽车的狭长停车场，它只有一个大门利用供车辆进出，车辆按到达停车场时间早晚依次可以从停车场最里面向大门处停

放（最先到达的第一辆放在停车场最里面）。然后停车场已放满N辆车，则

后来的车辆只能停在车场大门外的便道上等待，一旦停车场有车开走，在

它之后进入停车场的车必须先退出停车场为它让路，待其开出停车场后，

这些车辆再依原来的次序进场。每辆车在离开停车场时，都应依据它在停

车场内停留的时间长短交费。如果停留在便道上的未能进停车场就离去，

允许它走，不收停车费，而且仍然保持在便道上的等待的车辆的次序。编

制一程序模拟停车场的管理。

[实现要求]

要求程序输出每辆车到达后的停车位置（停车场或便道上），以及某辆车离开停车场时应交的费用和它在停车场内停留时间；

[实现提示]

汽车的模拟输入信息格式可以是：（到达/离去，汽车牌照号码，到达/离去的时刻）。例如，（A，1，5）表示1号牌照车在5这个时刻到达，而（D，

5，20）表示5号车在20这个时刻离去，整个程序可以在输入信息为（E，

0，0）时结束。本题可用栈和队列来实现。

[程序实现]

（1）设计思想

根据题目要求，停车场只有一个大门，因此可用一个栈来模拟；而当栈满后，继续来的车辆只能停在便道上，根据便道停车的特点，可知这可

以用一个队列来模拟，安排队的车辆先离开便道，进入停车场。由于在停

车场中间的车辆可以提出离开停车场，而且要求在离开车辆到停车场大门

之间的车辆都必须先离开停车场，让此车离去，然后再让这些车辆依原来

的次序进入停车场，因此在一个栈和一个队列的基础上，还需要有一个地

方保存为了让路离开停车场的车辆，很显然这也应该用一个栈来模拟。因

此本题中用到两个栈和一个队列。

对于停车场和车辆规避所，有车辆进入和车辆离去两个动作，这就是栈的进栈和出栈操作，只是还允许排在中间的车辆先离开停车场，因此

在栈中需要进行查找。而对于便道，也有入队列和出队列的操作，同样允

许排在中间的车辆先离去队列。这样基本动作只需利用栈和队列的基本操

作就可实现。

三、详细设计：

#include "stdio.h"

#define N 5 /*定义停车场长度*/

#define M 10

typedef struct /*定义栈元素的类型*/

{int num;

int arrtime;

}elemtype;

typedef struct /*定义栈*/

{elemtype stack[N];

int top;

}stack;

typedef struct node /*定义队列节点类型*/

{int num;

struct node*next;

}queneptr;

typedef struct /*定义队列*/

{queneptr*front,*rear;

}quene;

void initstack(stack*s) /*初始化栈*/

{s->top=-1;

}

int push(stack *s,elemtype x) /*数据元素X进入指针S所指的栈*/

{if(s->top==N-1)

return(0);

else{s->stack[++s->top]=x;

return(1);

}

}

elemtype pop(stack *s)

{elemtype x;

if(s->top<0)

{x.num=0;

x.arrtime=0;

return(x); /*如果栈不空，返回栈顶元素*/

}

else{x=s->stack[s->top];

s->top--;

return x;

}

}

void initquene(quene*s) /*初始化队列*/

{s->front=(queneptr*)malloc(sizeof(queneptr)); /*产生一个新结点，作为

头结点*/

s->rear=s->front;

s->front->next=NULL;

s->front->num=0; /*头结点的NUM保存队列元素的个数*/ }

void enquene(quene *s,int num) /*数据入队列*/

{queneptr *p;

p=(queneptr*)malloc(sizeof(queneptr));

p->num=num;

p->next=NULL;

s->rear->next=p;

s->rear=p;

s->front->num++;

}

int delquene(quene*s)

{queneptr*p;

int n;

if (s->front==s->rear)

return(0); /*如果队列空*/

else{p=s->front->next;

s->front->next=p->next;

if (p->next==NULL)

s->rear=s->front;

n=p->num;

free(p);

s->front->num--;

return(n);

}

}

void arrive(stack*s1,quene*p,elemtype x)

{int f;

f=push(s1,x); /*新到达的车辆入停车栈*/

if (f==0)

{enquene(p,x.num); /*如果停车场满，就进入队列*/

printf("the %d car stops the %d seat of the quene\n",x.num,p->front->num);

}

else printf("the %d car stops the %d seat of the stack\n",x.num,s1->top+1);

}

void leave(stack *s1,stack *s2,quene*p,elemtype x) /*处理车辆离去函数*/

{int n,f=0;

elemtype y;queneptr *q;

while((s1->top>-1)&&(!f))

{y=pop(s1);

if(y.num!=x.num)

n=push(s2,y);

else f=1;

}

if(y.num==x.num) /*如果栈顶元素不是要离开的车辆，就将其放入车辆规避所*/

{printf("the money of the %d is %d yuan\n",y.num,(x.arrtime-y.arrtime)*M);

while(s2->top>-1)

{y=pop(s2);

f=push(s1,y);

}

n=delquene(p);

if(n) /*在停车场中找到要离开的车辆*/

{y.num=n;

y.arrtime=x.arrtime;

f=push(s1,y);

printf("the %d car stops the %d seat of the stak\n",y.num,s1->top+1);

}

}

else {while(s2->top>-1) /*车辆规避所不空，将其全放回停车场*/ {y=pop(s2);f=push(s1,y);}

q=p->front;f=0;

while(f==0&&q->next!=NULL)

if(q->next->num!=x.num) /*如果便道上有车辆，将第一辆车放入停车场*/ q=q->next;

else {q->next=q->next->next;

p->front->num--;

if(q->next==NULL)

p->rear=p->front;

printf("the %d car leave the quene\n",x.num);

f=1;

}

if(f==0) /*在便道上没有找到要离开的车辆，输出数据错误*/ printf("error!the stack and the quene have no the%d car\n",x.num); }

}

void main() /*停车场模拟管理程序*/

{char ch;

stack *s1,*s2;

quene*p;

elemtype x;

int i=1;

clrscr();

s1=(stack*)malloc(sizeof(stack));

s2=(stack*)malloc(sizeof(stack));

p=(quene*)malloc(sizeof(quene));

initstack(s1);initstack(s2); /*初始化停车规避所栈*/

initquene(p); /*初始化便道队列*/

while(i)

{

printf("what do you want to do?\n");

printf("input---(Add/Del/Exit):");

scanf("%c",&ch);

switch (ch)

{case'a':printf("input the number:\n");

scanf("%d",&x.num);

printf("input the time:\n");

scanf("%d",&x.arrtime);

arrive(s1,p,x); /*车辆到达*/

break;

case'd':printf("input the number:\n");

scanf("%d",&x.num);

printf("input the time:\n");

scanf("%d",&x.arrtime);

leave(s1,s2,p,x); /*车辆离开*/

break;

case'e':printf("the end!");

i=0;

break;

default:{printf("input error!---please input again:\n");break;} }

ch=getchar();

}

}

四、使用说明：

1、按提示输入车进入停车场的情况

2、按提示输入车离开停车场的情况

3、车离开后计算车进入停车场的时间并得出应收费用。

五、测试结果：

运行程序后，屏幕出现

what do you want to do?

Input ----(add/del/exit)

/*此时停车场为空，a是车进入停车场，d是车离开停车场，e是程

序结束。*/

a

input the number： /*要求输入停车牌号*/

1

input the time： /*要求输入停车时间*/

2

：/*屏幕返回到提示，可以按以上方法输入多个数据*/

：

what do you want to do ?

input ----(add/del/exit) /*当输入多个数据后，可以设计车离

开*/

d

input the number: /*要求输入要离开车牌号*/

input the time： /*要求输入车离开的时间*/

5

the money of the 1 is 30 yuan /*输出结果，1小时10元计价

收费*/

实验三栈

一、实验目的：

1．熟练掌握栈的结构，以及这种数据结构的特点；

2．能够在两种存储结构上实现栈的基本运算，特别注意栈满和栈空的判断条件及描述方法；

二、实验内容：

计算表达式的值

【问题描述】

计算用运算符后缀法表示的表达式的值。后缀表达式也称逆波兰表达式，比中缀表达式计算起来更方便简单些，中缀表达式要计算就存在着括号的匹配问题，所以在计算表达式值时一般都是先转换成后缀表达式，再用后缀法计算表达式的值。如：表达式(a+b*c)/d-e用后缀法表示应为abc*+d/e-。只考虑四则算术运算，且假设输入的操作数均为1位十进制数（0—9），并且输入的后缀形式表达式不含语法错误。

【数据描述】

#define add 43 /*运算符加号‘+’的ASCII码*/

#define subs 45 /*运算符减号‘-’的ASCII码*/

#define mult 42 /*运算符乘号‘*’的ASCII码*/

#define div 47 /*运算符除号‘/’的ASCII码*/

#define MAXSIZE 100

typedef struct{

{ int stkdata[MAXSIZE];//用数组来表示栈空间，定义长度为MAXSIZE的栈

int top; //栈顶指针

}STKzone;

typedef STKzone *STK;

typedef enum{true=1,false=0} bool;

typedef enum{ok,error} status;

【算法描述】

用流程图表示见图3-4。

【C源程序】

#include

#define add 43 /*运算符加号‘+’的ASCII码*/

#define subs 45 /*运算符减号‘-’的ASCII码*/

#define mult 42 /*运算符乘号‘*’的ASCII码*/

#define div 47 /*运算符除号‘/’的ASCII码*/

#define MAXSIZE 100

typedef struct

{ int stkdata[MAXSIZE];/*用数组来表示栈空间，定义长度为MAXSIZE的堆栈*/

int top; /*栈顶*/

}STKzone;

typedef STKzone *STK;

typedef enum{true=1,false=0} bool;

typedef enum{ok,error} status;

STKzone expSTKzone;

STK expSTK;

STK initSTK(STKzone *stack_zone){

/*执行栈初始化，建栈指针*/

STK p;

p=stack_zone;

p->top=0;

}

status push(int *term,STK pstk){

/*将一结构型数据送入栈中*/

if(pstk->top==MAXSIZE)

return error; /*栈满，进栈失败*/

pstk->stkdata[pstk->top] =*term;

(pstk->top)++;/*栈顶指针移动*/

return ok;

}/*push*/

bool emptySTK(STK pstk){

/*判断栈是否为空栈*/

return(pstk->top==0);

}

status pop(int *pdata, STK pstk){

/*从栈中取出一结构型数据*/

if(emptySTK(pstk))

return error;

(pstk->top)--;/*退栈*/

*pdata =pstk->stkdata[pstk->top];

return ok;

}

void synerror()

{ printf("\n表达式语法错！");

exit();

}

int eval(char tag,int a1,int a2)

{ switch(tag)

{ case add:return(a1+a2);

case subs:return(a1-a2);

case mult:return(a1*a2);

case div:return(a1/a2);

}

}

main()

{ char c;

int opd1,opd2,temp,c1;

expSTK=initSTK(&expSTKzone);

printf("\n后置表达式:");

while((c=getchar())!='\n')

{ if(c== ' ') continue;

if((c>47)&&(c<58)) /*判断是否是0—9的字符*/ { putchar(c);

c1=c-48; /*把输入的字符型数字转换成数字*/

if(push(&c1,expSTK)==error)/*运算分量进栈*/

{ printf("\n表达式太长\n");

exit();}

}

else if((c==add)||(c==subs)||(c==mult)||(c==div))

{ putchar(c);

if(pop(&opd1,expSTK)==error) /*将运算量1出栈*/

synerror();

if(pop(&opd2,expSTK)==error) /*将运算量2出栈*/

synerror();

temp=eval(c,opd2,opd1);/*计算得到结果*/

push(&temp,expSTK);/*将运算结果进栈*/

}

else synerror();/*出现非法字符*/

}/*while*/

if(pop(&opd1,expSTK)==error) synerror();

if(!(emptySTK(expSTK))) synerror();

printf(“=%-3d\n”,opd1);

}/*main_end*/

【测试数据】

输入: 23+↙

输出: =5 (即求2+3的结果)

输入: 145*+3/3-↙

输出: 4 (即求(1+4*5)/3-3的结果)

【说明】

本算法中对后置法表示的表达式求值按如下规则进行：自左向右扫描，每遇到一个`n+1元组（opd1,opd2,…,opdn,opr）(其中opd为操作数，opr为n元运算符)，就计算一次opr （opd1,opd2,…,opdn）的值，其结果取代原来表达式中n+1元组的位置，再从表达式开头重复上述过程，直到表达式中不含运算符为止。

【实验题】

1. 1.假设一个算术表达式中包含零对到多对圆括弧，括弧对之间允许嵌套但不允许交

叉，编写一个算法并上机实现：判断输入的表达式是否正确配对。

Status correct(string express)；//括弧配对正确，返回ok，否则返回error

2. 2.用栈实现一般表达式（即中缀表达式）到后缀表达式的转换。

实验四二叉树的操作

一、实验目的

理解并熟悉掌握创建二叉树和实现二叉树的三种遍历

二、实验内容

创建二叉树和实现二叉树的三种遍历

a.根据提示输入字符型数据创建二叉树，输入值为所有字符型数据

b.输出为遍历后的每个结点的值的顺序

c.创建二叉树并能实现二叉树的先序、中序、后序遍历

d.如果输入数据为：a b c

输出结果为：a b c

b a c

b c a

程序流程：main()→clrscr()→createtree()→preorder()→inorder()→postorder

三、源程序

#include "stdlib.h" /*引入头文件*/

struct tnode /*定义二叉树存储结构*/

{char data;

struct tnode*lchild;

struct tnode*rchild;

};

struct tnode tree; /*定义二叉树指针*/

void createtree(struct tnode*t) /*创建函数*/

{struct tnode*p=t; /*把二叉树指针给p*/

char check;

if(p->lchild==NULL||p->rchild==NULL) /*判断左右子树是否为空*/

{printf("please enter the data:"); /*输入根结点数据*/

scanf("%c",&(p->data));

getchar();

}

if(p->lchild==NULL)

{printf("%c leftchild is null.Add? y/n\n",p->data); /*左子树空，询问是否创建*/

scanf("%c",&check);

getchar();

if(check=='y')

{struct tnode*q=(struct tnode*)malloc(sizeof(struct tnode)); /*开辟空间*/

q->lchild=NULL;

q->rchild=NULL;

p->lchild=q;

createtree(q);

}

}

if(p->rchild==NULL)

{printf("%c rightchild is NULL.Add? y/n\n",p->data); /*右子树空，询问是否创建*/ scanf("%c",&check);

getchar();

if(check=='y')

{struct tnode*q=(struct tnode*)malloc(sizeof(struct tnode)); /*开辟空间*/

q->lchild=NULL;

q->rchild=NULL;

p->rchild=q; /*连到二叉树上*/

createtree(q);

}

}

}

void preorder(struct tnode*t) /*先序遍历函数*/

{if(t)

{printf("%c ",t->data); /*输出根结点数据*/

preorder(t->lchild);

preorder(t->rchild);

}

}

void inorder(struct tnode*t) /*中序遍历函数*/

{if(t)

{inorder(t->lchild);

printf("%c ",t->data);

inorder(t->rchild);

}

}

void postorder(struct tnode*t) /*后序遍历函数*/

{if(t)

{

postorder(t->lchild);

postorder(t->rchild);

printf("%c ",t->data);

}

}

void main()

{

clrscr(); /*清屏函数*/

tree.lchild=NULL; /*左子树*/

tree.rchild=NULL; /*右子树*/

createtree(&tree); /*创建二叉树*/

preorder(&tree); /*先序遍历*/

printf("\n");

inorder(&tree); /*中序遍历*/

printf("\n");

postorder(&tree); /*后序遍历*/

}

四、使用说明

程序运行：

1、先输入根结点数据，例如：a

2、输入y或n判断是否创建左子树。输入y然后输入左子树数据

3、输入y或n判断是否创建右子树。输入y然后输入右子树数据

4、按回车可查看遍历结果并退出程序。

五、测试结果

运行程序，屏幕提示：

please enter the data:a /*首先输入根结点，为a*/

a leftchild is null.add?y/n /*询问是否输入a结点的左结点*/

y /*输入*/

please enter the data:b /*输入结点a的左结点，为b*/

b leftchild is null.add?y/n /*询问是否输入b结点的左结点*/

n /*不输入*/

b rightchild is null.add?y/n /*询问是否输入b结点的右结点*/

n /*不输入*/

a rightchild is null.add?y/n /*询问是否输入a结点的右结点*/

y /*输入*/

please enter the data:c /*输入结点a的右结点，为c*/

c leftchil

d is null.add?y/n /*询问是否输入c结点的左结点*/

n /*不输入*/

c rightchil

d is null.add?y/n /*询问是否输入c结点的右结点*/

n /*不输入*/

程序退出，显示结果应为：

a b c /*先序*/

b a

c /*中序*/

b c a /*后序*/

实验五图的遍历操作

一、实验目的：

该程序主要完成对图的创建，并实现图的深度优先遍历和广度优先遍历

二、实验内容：

1、所输入的数据要为整形数据

2、输出的形式为：每按一次回车，遍历一个结点

3、能创建最大结点树为30的任意图，实现对无向图的两种遍历

程序流程：

main()→clrscr()→visited()→DFS()→visited()→BFS()

三、源程序：

#include /*引用两个头文件*/

#define maxvex 30 /*定义MAXVEX=30*/

struct edgenode /*定义边的结构体*/

{int adjvex;

char info;

struct edgenode*next;

};

struct vexnode /*定义点的结构体*/

{char data;

struct edgenode*link;

};

typedef struct vexnode adjlist[maxvex]; /*自定义adjlist为结构体数组类型*/

adjlist tu1; /*定义结构体数组变量tu1*/

void creategraph(adjlist g,int n) /*图创建函数*/

{int e,i,s,d; /*定义存储边、点的变量*/

struct edgenode*p,*q; /*定义边的结构体指针*/

printf("the point(n) and edge(e):"); /*显示提示输入点，边*/

scanf("%d,%d",&n,&e); /*接收点、边存入n,e中*/

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

{getchar();

printf("\tthe %d information:",i); /*提示输入结点信息*/

scanf("%c",&g[i].data); /*存储信息*/

g[i].link=NULL; /*最后指针为空*/

}

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

{printf("\nthe%d edges=>\n\t :",i); /*提示输入边信息*/

scanf("%d,%d",&s,&d); /*接收边的信息*/

p=(struct edgenode*)malloc(sizeof(struct edgenode));

q=(struct edgenode*)malloc(sizeof(struct edgenode)); /*开辟两个存储边的空间*/ p->adjvex=d; /*把其中一个点存储下来*/

p->info=g[d].data;

q->adjvex=s; /*把另一个点存储下来*/

q->info=g[s].data;

p->next=g[s].link; /*p和s的link指针连接起来*/

g[s].link=p;

q->next=g[d].link; /*q和s的link指针连接起来*/

g[d].link=q; /*完成一个边的创建*/

}

}

int visited[maxvex]; /*定义访问数组*/

void dfs(adjlist adj,int v) /*深度优先遍历函数*/

{int i;

struct edgenode*p; /*定义边指针*/

visited[v]=1; /*把开始遍历的点在访问数组中标识*/ printf("now is at point %d",v); /*输出正访问的点*/

p=adj[v].link;

printf("the data is %c \n",adj[v].data); /*输出点的信息*/

getch();

while(p)

{if(visited[p->adjvex]==0)

dfs(adj,p->adjvex); /*没有访问的再调用DFS函数*/ p=p->next; /*访问过的判断下一个*/

}

}

int quene[maxvex];

void bfs(adjlist adj,int vi) /*广度优先遍历函数*/

{int m=maxvex; /*定义一个队列*/

int front=0,rear=1,v;

struct edgenode*p; /*定义边指针*/

visited[vi]=1; /*开始访问的点标识一下*/

printf("now visit the point:%d\n",vi); /*输出正访问的点*/

getch();quene[rear]=vi; /*把访问过的点放入数组中*/

while(front!=rear)

{front=(front+1)%m;

v=quene[front];

p=adj[v].link;

while(p)

{if(visited[p->adjvex]==0) /*判断p->adjvex点是否访问过*/

{visited[p->adjvex]=1; /*访问没有访问过的结点*/

printf("now visit the point:%d\n",p->adjvex); /*输出正访问的结点*/

getch();

rear=(rear+1)%m;

quene[rear]=p->adjvex; /*放入数组中*/

}

p=p->next; /*指向下一个*/

}

}

}

void main()

{int i;clrscr();

creategraph(tu1,0); /*创建图*/

for(i=1;i

visited[i]=0; /*访问数组初始化*/

dfs(tu1,1); /*调用DFS*/

getch(); /*等待输入*/

for(i=1;i

visited[i]=0;

bfs(tu1,1); /*调用BFS*/

}

四、使用说明：

根据屏幕上的英文提示先输入结点的个数和边数。然后输入各结点存储的信息，再输入定义的边，形成图。最后分别按照DFS深度优先遍历和BFS广度优先遍历实现对图的遍历。

五、测试结果：

运行程序，屏幕提示：

the point(n) and edge(e):4,3 /*输入顶点和边的数目*/

the 1 information:a /*各个顶点的信息*/

the 2 information:b

the 3 information:c

the 4 information:d

the 1 edges=> /*各个边的连接情况*/

:1,2

the 2 edges=>

:1,3

the 3 edges=>

:3,4

now is at point 1 the data is a /*深度优先遍历结果*/

now is at point 3 the data is c

now is at point 4 the data is d

now is at point 2 the data is b

now visit the point:1 /*广度优先遍历结果*/

now visit the point:3 now visit the point:2 now visit the point:4