基于图的简单信息管理系统（没连接数据库）

功能概述：
1.鸵鸟和鸵鸟之间可能具有某种关系，如亲缘关系，某某是某某的父亲或母亲等等，在这里如果A与B有联系，就用 A→B表示，这样就会出现多个人与多个人产生联系从而形成了一个有向的关系网即一个有向图。
2.将这个有向图通过邻接表的形式储存起来，然后通过邻接表进行深度和广度遍历，并且可以进行增加，查询，修改，删除等操作
3.如查询操作 既可以只查询一个人的信息，也可以查询与之相关的所有人的信息，这种操作就具有了一定的实际意义

用到的知识：
1.链表的基本操作
2.图的建立及其基本操作
3.DFS+BFS
4.队列的创建及其基本操作

//main.c 主函数文件
#include <stdio.h>
#include <stdlib.h>
#include "cirQueueDef.h"
#include "cirQueueAlgo.h"
#include "GraphDef.h"
#include "GraphAlgo.h"

void main()
{
system("color E5");
int flag;ALGraph ALG;	
	while(1){
	printf("1-建立链表\n");
	printf("2-DFS\n");
	printf("3-BFS\n");
	printf("4-查询某个鸵鸟及其相关的所有人信息\n");
	printf("5-删除某个鸵鸟及其相关的信息\n");
	printf("6-退出\n");
	printf("请输入序号:\n");
	scanf("%d",&flag);
	switch(flag)
	{
		case 1: 
			
			CreateALGraph(&ALG);
			printf("\n				建立的邻接表:\n");
			printf("------------------------------------------------------------------\n");
			PrintALGraph(&ALG);
			printf("------------------------------------------------------------------\n");
			break;
		case 2:
			//ALGraph ALG;
			
			printf("\n				DFS:");printf("\n------------------------------------------------------------------\n");
			printf("%s	%s	%s	%s	%s	%s	%s	%s\n","顶点","编号","食性","性别","身高","体重","年龄","等级");
			DFSTraverseAL(&ALG);printf("------------------------------------------------------------------\n");
			break;
		case 3:
			//ALGraph ALG;
			
			printf("\nBFS:\n");printf("\n------------------------------------------------------------------\n");
			printf("%s	%s	%s	%s	%s	%s	%s	%s\n","顶点","编号","食性","性别","身高","体重","年龄","等级");
			BFSTraverseAM(&ALG);printf("------------------------------------------------------------------\n");;
			break;

		case 4:
			int k;printf("\n------------------------------------------------------------------\n");
			printf("\n输入要查询某人及其相关的所有人信息的编号:\n");
			printf("输入编号:");
			scanf("%d",&k);
			printf("%s	%s	%s	%s	%s	%s	%s	%s\n","顶点","编号","食性","性别","身高","体重","年龄","等级");
			SearchRelative(&ALG,k);printf("------------------------------------------------------------------\n");;
			break;

		case 5:
			int bh;
			printf("\n------------------------------------------------------------------\n");
			printf("输入删除某个人及其相关的信息的顶点号:\n");
			scanf("%d",&bh);printf("------------------------------------------------------------------\n");
			printf("%s	%s	%s	%s	%s	%s	%s	%s\n","顶点","编号","食性","性别","身高","体重","年龄","等级");
			Delet(&ALG,bh);
			BFSTraverseAM(&ALG);
			printf("------------------------------------------------------------------\n");
			break;
	
		case 6:

			return;
	}
	}

}

//#include "GraphDef.h" 定义图结构体
typedef struct node	
{   char adjvex;         
	
	struct node  * next;      
    
}EdgeNode;
typedef struct vnode 	      	//顶点表
{ 
  char vertex[5];          	
  char name[5];
  int bianhao;
  char sex[5];
  int height;
  int weight;
  int nianling;
  int dengji;int t[7];
  EdgeNode  * firstedge;      //边表头
	                
}VertexNode;   
typedef struct
{  VertexNode   adjlist[10];    
    int n, e;                  
}ALGraph;  //邻接表存储

int visited[10];




 

//#include "cirQueueDef.h" 定义队列结构体
#define  MAXSIZE  1024	
typedef  int  elemtype;	
typedef  struct  SequenQueue
{	elemtype  data[MAXSIZE];	
                                      
	int  front;			
	int  rear;			
}SequenQueue;	

/*
* #include "GraphAlgo.h"文件 完成基本功能
*/
void CreateALGraph(ALGraph *G)
{   int i,j,k;	    EdgeNode * s;
    printf("请输入鸵鸟个数和关系个数(个数,关系个数)：\n");
    scanf("%d, %d", &(G->n), &(G->e));  
    printf("\n请输入各个点信息:\n");
    for (i = 0; i < G->n; i++)                 	
    {  
		printf("顶点:");  
		scanf("%s", &(G->adjlist[i].vertex)); 
		printf("编号:");
		scanf("%d",&(G->adjlist[i].bianhao));
		printf("食性:");
		scanf("%s",&(G->adjlist[i].name));
		//gets(p->name);
		printf("性别:");
		scanf("%s",&(G->adjlist[i].sex));
		printf("身高:");
		scanf("%d",&(G->adjlist[i].height));
		printf("体重:");
		scanf("%d",&(G->adjlist[i].weight));
		printf("年龄:");
		scanf("%d",&(G->adjlist[i].nianling));
		printf("等级:");
		scanf("%d",&(G->adjlist[i].dengji));
		G->adjlist[i].firstedge = NULL;  
	} 
	
	printf("\n请输入边的关系(输入格式为:i,j)表示i和j具有关系:\n");
    for (k=0; k<G->e; k++)                    
    {       
		scanf("%d, %d", &i, &j); 
        s = (EdgeNode*)malloc(sizeof(EdgeNode));  
        s->adjvex = j;                        
        s->next = G->adjlist[i].firstedge;  
        G->adjlist[i].firstedge = s;
		
    }
}
void PrintALGraph(ALGraph *G)
{
	int i;
	EdgeNode * p;
	printf("顶点符号	领接信息\n");
	for(i=0;i<G->n;i++)
	{int i1=0;
		printf("%s",G->adjlist[i].vertex);
		p=G->adjlist[i].firstedge;
		if(!p)
			printf("		  NULL");
		while(p)
		{	
			printf("		 %4d  ",p->adjvex);
			
			G->adjlist[i].t[i1]=p->adjvex;
			i1++;p=p->next;
		}
		printf("\n");

	}
}

void DFSAL(ALGraph *G, int i)	
{	EdgeNode *p;
	printf("%s	%d	%s	%s	%d	%d	%d	%d	\n",G->adjlist[i].vertex, G->adjlist[i].bianhao,G->adjlist[i].name,G->adjlist[i].sex,
		G->adjlist[i].height,G->adjlist[i].weight,G->adjlist[i].nianling,G->adjlist[i].dengji); 
	visited[i]=1;                     
	p=G->adjlist[i].firstedge;       
	while(p)                            	  
	{	if (!visited[p->adjvex])    
			
	       		DFSAL(G, p->adjvex);
	    	p=p->next;                 
	}
}
void SearchRelative(ALGraph *G,int bianhao){//需改进
	EdgeNode *p;
	for(int k=0;k<G->n;k++)
		if(G->adjlist[k].bianhao==bianhao){
			printf("%s	%d	%s	%s	%d	%d	%d	%d	\n",G->adjlist[k].vertex, G->adjlist[k].bianhao,G->adjlist[k].name,G->adjlist[k].sex,
			G->adjlist[k].height,G->adjlist[k].weight,G->adjlist[k].nianling,G->adjlist[k].dengji);
			p=G->adjlist[k].firstedge; 
			while (p) {
				p=p->next;
				for (int j=0; j<G->n; j++) 
					for(int t2=0;t2<7;t2++)
						if(j==G->adjlist[k].t[t2]){ 		
						printf("%s	%d	%s	%s	%d	%d	%d	%d	\n",G->adjlist[j].vertex, G->adjlist[j].bianhao,G->adjlist[j].name,G->adjlist[j].sex,
						G->adjlist[j].height,G->adjlist[j].weight,G->adjlist[j].nianling,G->adjlist[j].dengji);
				}
					
		}

	}
}
void Delet(ALGraph *G,int bh){//未完成
	EdgeNode *p; 
	for(int k=0;k<G->n;k++)
		if(G->adjlist[k].bianhao==bh){
			p=G->adjlist[k].firstedge;
			if(!p) {	
				G->n--;

				for(int b=k;b<(G->n)-1;b++){
					G->adjlist[k]=G->adjlist[k+1];
			}
			/*else{
				while(p){}
				
			}*/
		}}

}

void DFSTraverseAL(ALGraph *G)	
{	int i;
	for (i=0; i<G->n; i++)
		visited[i] = 0;    
	for (i=0; i<G->n; i++) 
		if (!visited[i])       DFSAL(G, i);          		
}

void BFSM(ALGraph *G,  int k)
{   int i, j;     SequenQueue *Q;	
	//int t1;			
	Q=Init_SequenQueue();
	EdgeNode *p;
	printf("%s	%d	%s	%s	%d	%d	%d	%d	\n",G->adjlist[k].vertex, G->adjlist[k].bianhao,G->adjlist[k].name,G->adjlist[k].sex,
		G->adjlist[k].height,G->adjlist[k].weight,G->adjlist[k].nianling,G->adjlist[k].dengji); 
		p=G->adjlist[k].firstedge;        
		visited[k] = 1;   
		Enter_SequenQueue(Q, k);                  
    while (!SequenQueue_Empty(Q))
		{	i=Delete_SequenQueue(Q);  
		p=G->adjlist[i].firstedge;
		
			while (p) {p=p->next;
				for (j=0; j<G->n; j++) 
					for(int t2=0;t2<7;t2++){
					if(j==G->adjlist[i].t[t2]&&visited[j] != 1){ 		
					printf("%s	%d	%s	%s	%d	%d	%d	%d	\n",G->adjlist[j].vertex, G->adjlist[j].bianhao,G->adjlist[j].name,G->adjlist[j].sex,
					G->adjlist[j].height,G->adjlist[j].weight,G->adjlist[j].nianling,G->adjlist[j].dengji); 
            		visited[j] = 1;
					Enter_SequenQueue(Q, j); }}
					
			}
		}
}
void BFSTraverseAM(ALGraph *G)
{	int i;
    for (i=0; i<G->n; i++)
       	visited[i] = 0;            
	for (i=0; i<G->n; i++)
		if (!visited[i]) 	    
			BFSM(G, i);
}

//#include "cirQueueAlgo.h"文件 实现队列的基本操作 
SequenQueue * Init_SequenQueue( ){	SequenQueue *Q;	
                                
	Q = (SequenQueue *) malloc ( sizeof( SequenQueue ) );
 	Q->front = 0;		
                                 
 	Q->rear = 0;		
                                
	return Q;		
}
int SequenQueue_Empty(SequenQueue *Q){
	if ( Q->front == Q->rear )	
                      
		return 1; 		
	else 
		return 0; 	
                      	
}
int SequenQueue_Full(SequenQueue *Q)
{	if ( (Q->rear+1) % MAXSIZE == Q->front )
	{	return 1; 			} 
	else
	{	return 0; 			}
}
int SequenQueue_Length (SequenQueue *Q)
	
{return   ( (Q->rear- Q->front+ MAXSIZE) % MAXSIZE );}
           

int Enter_SequenQueue(SequenQueue *Q, elemtype x )
	
{	if (SequenQueue_Full(Q))		                               
              return 0;   	
	Q->data[Q->rear] = x;	 
	Q->rear = (Q->rear + 1) % MAXSIZE; 
                                                      
	return 1;			
}
elemtype  Delete_SequenQueue(SequenQueue  *Q)
                         
{	elemtype x;
	if (Q-> front == Q->rear) 
	{	
		return -1; 
	} 
	else
	{	x = Q->data[Q-> front];	
                         
		Q-> front = (Q-> front + 1) % MAXSIZE;	       
		return x;	
	}
}
int  GetFront_SequenQueue(SequenQueue  *Q, elemtype *x)
            
{	if (Q-> front == Q->rear)
                      	
	{	
		return 0;   
	} 
	else
	{	*x = Q->data[Q-> front];
                                      
		return 1;	
	}
}

运行结果：
|
|
|