数据结构实验设计报告

小吉在努力

已于 2022-05-31 21:30:23 修改

阅读量378

点赞数

文章标签：数据结构链表 list c语言图论

于 2022-05-31 21:10:36 首次发布

本文链接：https://blog.csdn.net/weixin_64393298/article/details/125073445

版权

实验一链表

#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);
}