链表版本图的深度优先和广度优先遍历

链表头文件

#ifndef __LINKLIST_H__
#define __LINKLIST_H__
typedef void LinkList;//链表的数据封装 
typedef struct _tag_LinkListNode LinkListNode;//指针域的重命名，指针域的定义最重要，在链表中遍历节点的时候就是利用指针域的移动，
//他既包含了当前节点的地址信息，由于它是结构体，所以又包含了下一个节点的地址信息； 
struct  _tag_LinkListNode{//指针域结构体的具体定义 
	LinkListNode* next;//用指针域定义指针域 
};

LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

LinkListNode* LinkList_Get(LinkList* list, int pos);

#endif

链表实现文件

#include <stdio.h>
#include <malloc.h>
#include "LinkList.h"

typedef struct _tag_LinkList{//表头结构体 
	LinkListNode header;//表头指针，header是一个结构体，成员是一个指针 
	int length;//链表长度成员,在这里没有直接定义链表节点成员 
}TLinkList;

LinkList* LinkList_Create()
{
	TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));//动态分配空间，刚刚创建的时候只需要分配表头的空间 
	if (ret != NULL){
		ret->length = 0;//对长度初始化为0 
		ret->header.next = NULL; //对表头指针成员初始化为NULL 
	}
	return ret;//返回表头地址 
}


void LinkList_Destroy(LinkList* list)
{
	free(list);
}

void LinkList_Clear(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;
	if (sList != NULL){//让表头恢复到刚刚创建的状态 
		sList->length = 0;
		sList->header.next = NULL;
	}
}

int LinkList_Length(LinkList* list)
{
	TLinkList* sList = (TLinkList*)list;//除了destroy函数，其余函数基本上都会用到强制类型转换 
	int ret = -1;
	if (sList != NULL){//如果合法则返回当前长度 
		ret = sList->length;
	}
	return ret;
}

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	TLinkList* sList = (TLinkList*)list;//强制类型转换 
	int ret = (sList != NULL) && (pos >= 0) && (node != NULL);//合法性检测 
	int i = 0;

	if (ret){
		LinkListNode* current = (LinkListNode*)sList;//将表头指针强制转换为当前指针。结构体指针指向结构体中的第一个成员 
		for (i = 0; (i < pos) && (current->next != NULL); i++){//移动当前指针，使得当前指针的指针域指向的元素的位置即要插入新元素的位置 
			current = current->next;
		}
		node->next = current->next;//将当前指针指向的下一个元素的位置赋值给要插入的节点的指针域 
		current->next = node;//将要插入的节点的位置赋值给当前指针的指针域 
		sList->length++;//更新长度 
	}
	return ret;//成功插入返回1否则返回0 
}

LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;
	if ((sList != NULL) && (pos >= 0) && (pos < sList->length)){//合法性检测 
		LinkListNode* current = (LinkListNode*)sList;//将表头指针赋值为当前指针 
		for (i = 0; i < pos; i++){//移动当前指针使得它的指针域指向要获取的节点 
			current = current->next;
		}
		ret = current->next;//返回获取的节点 
	}
	return ret;//返回的是结构体的指针，即结构体的地址 
}

LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	TLinkList* sList = (TLinkList*)list;
	LinkListNode* ret = NULL;
	int i = 0;
	if ((sList != NULL) && (pos >= 0) && (pos < sList->length)){
		LinkListNode* current = (LinkListNode*)sList;
		for (i = 0; i < pos; i++){
			current = current->next;
		}
		ret = current->next;
		current->next = ret->next;//将当前指针的指针域指向要删除的节点的指针域，即可删除节点 
		sList->length--;//更新长度成员 
	}
	return ret;
}

队列头文件

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

typedef void LinkQueue;

LinkQueue* LinkQueue_Create();

void LinkQueue_Destroy(LinkQueue* queue);

void LinkQueue_Clear(LinkQueue* queue);

int LinkQueue_Append(LinkQueue* queue, void* item);

void* LinkQueue_Retrieve(LinkQueue* queue);

void* LinkQueue_Header(LinkQueue* queue);

int LinkQueue_Length(LinkQueue* queue);

#endif

队列实现文件

#include <malloc.h>
#include <stdio.h>
#include "LinkQueue.h"

typedef struct _tag_LinkQueueNode TLinkQueueNode;
struct _tag_LinkQueueNode{
	TLinkQueueNode* next;
	void* item;
};

typedef struct _tag_LinkQueue{
	TLinkQueueNode* front;
	TLinkQueueNode* rear;
	int length;
}TLinkQueue;

LinkQueue* LinkQueue_Create()
{
	TLinkQueue* ret = (TLinkQueue*)malloc(sizeof(TLinkQueue));

	if (ret != NULL){
		ret->front = NULL;
		ret->rear = NULL;
		ret->length = 0;
	}
	return ret;
}

void LinkQueue_Destroy(LinkQueue* queue)
{
	LinkQueue_Clear(queue);
	free(queue);
}

void LinkQueue_Clear(LinkQueue* queue)
{
	while (LinkQueue_Length(queue) > 0){
		LinkQueue_Retrieve(queue);
	}
}

int LinkQueue_Append(LinkQueue* queue, void* item)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	TLinkQueueNode* node = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));

	int ret = (sQueue != NULL) && (item != NULL) && (node != NULL);

	if (ret){
		node->item = item;
		if (sQueue->length > 0){
			sQueue->rear->next = node;
			sQueue->rear = node;
			node->next = NULL;
		}
		else{
			sQueue->front = node;
			sQueue->rear = node;
			node->next = NULL;
		}
		sQueue->length++;
	}
	if (!ret){
		free(node);
	}
	return ret;
}

void* LinkQueue_Retrieve(LinkQueue* queue)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	void* ret = NULL;
	TLinkQueueNode* node = NULL;
	if ((sQueue != NULL) && (sQueue->length > 0)){
		node = sQueue->front;

		sQueue->front = node->next;

		ret = node->item;

		free(node);

		sQueue->length--;


		if (0 == sQueue->length){
			sQueue->front = NULL;
			sQueue->rear = NULL;
		}
	}
	return ret;
}

void* LinkQueue_Header(LinkQueue* queue)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	void* ret = NULL;
	if ((sQueue != NULL) && (sQueue->length > 0)){
		ret = sQueue->front->item;
	}
	return ret;
}

int LinkQueue_Length(LinkQueue* queue)
{
	TLinkQueue* sQueue = (TLinkQueue*)queue;
	int ret = -1;
	if (sQueue != NULL){
		ret = sQueue->length;
	}
	return ret;
}

图头文件

/***************************************************************
*版权所有 (C)2014,练习。
*
*文件名称：
*内容摘要：
*其它说明：
*当前版本：
*作   者：
*完成日期：
*
*修改记录1：  //修改历史记录，包括修改日期、版本号、修改人及修改内容等
*   修改日期：
*   版本号：
*   修改人：
*   修改内容：
***************************************************************/
#ifndef __LGRAPH_H__
#define __LGRAPH_H__

/**************************************************************
相关宏定义
**************************************************************/

/**************************************************************
相关结构体定义
**************************************************************/


typedef void LGraph;//图的结构体定义，数据封装形式

typedef void LVertex;//顶点的结构体定义，数据封装形式

typedef void (LGraph_printf)(LVertex*);//重命名一个函数类型用来打印信息


/**************************************************************
创建一个顶点数为n的图，并返回其地址
**************************************************************/
LGraph* LGraph_Create(LVertex** v, int n);


/**************************************************************
销毁graph指向的图
**************************************************************/
void LGraph_Destroy(LGraph* graph);


/**************************************************************
将graph指向的图清空（清空的是顶点之间的边，而不是顶点本身）
**************************************************************/
void LGraph_Clear(LGraph* graph);


/**************************************************************
在graph所指的图中v1和v2之间加上边，且边的权为w
**************************************************************/
int LGraph_AddEdge(LGraph* graph,int v1,int v2,int w);


/**************************************************************
将graph所指图中v1和v2之间的边删除，返回权值
**************************************************************/
int LGraph_RemoveEdge(LGraph* graph, int v1, int v2);



/**************************************************************
将graph所指图中v1和v2之间的边的权值返回
**************************************************************/
int LGraph_GetEdge(LGraph* graph, int v1, int v2);


/**************************************************************
将graph所指图中v顶点的度返回
**************************************************************/
int LGraph_TD(LGraph* graph, int v);


/**************************************************************
将graph所指图中的顶点数返回
**************************************************************/
int LGraph_VertexCount(LGraph* graph);


/**************************************************************
将graph所指图中的边数返回
**************************************************************/
int LGraph_EdgeCount(LGraph* graph);

/**************************************************************

**************************************************************/
void LGraph_DFS(LGraph* graph, int v, LGraph_printf* pFunc);

/**************************************************************

**************************************************************/
void LGraph_BFS(LGraph* graph, int v, LGraph_printf* pFunc);

/**************************************************************
将graph所指图中的顶点之间的关系打印出来
**************************************************************/
void LGraph_Display(LGraph* graph, LGraph_printf* pFunc);

#endif

图实现文件

/***************************************************************
*版权所有 (C)2014,公司名称。
*
*文件名称：
*内容摘要：
*其它说明：
*当前版本：
*作   者：
*完成日期：
*
*修改记录1：   //修改历史记录，包括修改日期、版本号、修改人及修改内容等
*   修改日期：
*   版本号：
*   修改人：
*   修改内容：
*
*修改记录2：  //修改历史记录，包括修改日期、版本号、修改人及修改内容等
*   修改日期：
*   版本号：
*   修改人：
*   修改内容：
***************************************************************/



/**************************************************************
头文件引用
**************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "LGraph.h"
#include "LinkList.h"
#include "LinkQueue.h"

/**************************************************************
全局变量定义
**************************************************************/

typedef struct _tag_LGraph{
	int count;//顶点数量
	LVertex** v;//描述顶点相关数据的指针(顶点数组)
	LinkList** la;//（链表数组）描述顶点之间的边的关系的指针
}TLGraph;



/*链表节点结构体定义*/
typedef struct _tag_ListNode{
	LinkListNode header;//指向表头
	int v;//当前节点指向的下一节点
	int w;//权值
}TListNode;



static void recursive_dfs(TLGraph* graph,int v,int visited[],LGraph_printf* pFunc)
{
	int i = 0;
	pFunc(graph->v[v]);

	visited[v] = 1;//1表示已经访问过
	printf(",");

	for (i = 0; i < LinkList_Length(graph->la[v]);i++){
		TListNode* node = LinkList_Get(graph->la[v],i);
		if (!visited[node->v]){
			recursive_dfs(graph,node->v,visited,pFunc);
		}
	}
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：需要用到队列
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
static void recursive_bfs(TLGraph* graph, int v, int visited[], LGraph_printf* pFunc)
{
	LinkQueue* queue = LinkQueue_Create();

	if (queue != NULL)
	{
		LinkQueue_Append(queue, graph->v + v);//插入的是地址，因为队列里面不能插入0，所以插入地址，后面访问的时候求											//相对地址来代表实际的数据，graph->v是基地址

		visited[v] = 1;//表示已经访问过

		while (LinkQueue_Length(queue) > 0)//递归结束的条件，全部遍历过
		{
			int i = 0;

			v = (LVertex**)LinkQueue_Retrieve(queue) - graph->v;//将队列里面的数据取出，即访问刚刚插入的节点

			pFunc(graph->v[v]);

			printf(",");

			for (i = 0; i<LinkList_Length(graph->la[v]); i++)//依次访问下一层
			{
				TListNode* node = (TListNode*)LinkList_Get(graph->la[v], i);

				if (!visited[node->v])//如果没有访问过则加入队列以便访问
				{
					LinkQueue_Append(queue, graph->v + node->v);//插入地址

					visited[node->v] = 1;//标记已经访问
				}
			}
		}
	}

	LinkQueue_Destroy(queue);//有创建必然伴随着销毁
}
/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
LGraph* LGraph_Create(LVertex** v,int n)
{
	TLGraph* ret = NULL;
	if ((v != NULL) && (n > 0)){//有穷非空所以n大于0
		ret = (TLGraph*)malloc(sizeof(TLGraph));//申请一个头节点对象
		if (ret != NULL){
			ret->count = n;

			ret->v = (LVertex**)calloc(n,sizeof(LVertex*));//申请顶点数组空间


			ret->la = (int**)calloc(n,sizeof(LinkList*));//申请链表数组空间，里面的元素存放的是每一个链表的头节点
			
			int ok = (ret->v != NULL) && (ret->la != NULL);

			if (ok){
				int i = 0;
				for (i = 0; i < n;i++){
					ret->v[i] = v[i];//保存顶点数组
				}

				for (i = 0; (i < n) && (ok); i++){//为每一个链表申请空间，即创建链表
					ok = ((ret->la[i] = LinkList_Create()) != NULL) && ok;
				}
			}
			if(!ok){//申请不成功要释放空间
				if (ret->la != NULL){//销毁已经创建的部分链表
					int i = 0;
					for (i = 0; i < n;i++){
						LinkList_Destroy(ret->la[i]);
					}
					
				}
				free(ret->v);//释放顶点数组空间
				free(ret->la);//释放链表数组空间
				free(ret);//释放图（头节点）空间
				ret = NULL;
			}
		}
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void LGraph_Destroy(LGraph* graph)
{
	TLGraph* tGraph = (TLGraph*)graph;
	LGraph_Clear(graph);

	if (tGraph != NULL){
		int i = 0;
		for (i = 0; i < tGraph->count; i++){
			LinkList_Destroy(tGraph->la[i]);//销毁每一个单链表
		}
		free(tGraph->la);//销毁链表数组（该数组存放的是每一个单链表的起始地址，即单链表的头节点）
		free(tGraph->v);//销毁顶点数组
		free(tGraph);//销毁图的头节点本身
	}
}



/**********************************************************************
*功能描述：清空的是边，而不是顶点
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void LGraph_Clear(LGraph* graph)
{
	TLGraph* tGraph = (TLGraph*)graph;
	if (tGraph != NULL){
		int i = 0;
		for (i = 0; i < tGraph->count;i++){//遍历链表数组的每一个链表
			while (LinkList_Length(tGraph->la[i]) > 0){//如果链表长度还大于0，则要将里面的节点删除并释放空间
				free(LinkList_Delete(tGraph->la[i], 0));//clear函数free的是链表数组里的链表的节点
			}
		}
	}
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
int LGraph_AddEdge(LGraph* graph, int v1, int v2, int w)
{
	TLGraph* tGraph = (TLGraph*)graph;
	TListNode* node = NULL;
	int ret = (tGraph != NULL);
	ret = ret && (v1 >= 0) && (v1 < tGraph->count);
	ret = ret && (v2 >= 0) && (v2 < tGraph->count);
	ret = ret && (w > 0) && ((node = (TListNode*)malloc(sizeof(TListNode))) !=NULL);//邻接链表中w必须大于0

	if (ret){
		node->v = v2;
		node->w = w;

		LinkList_Insert(tGraph->la[v1],(LinkListNode*)node,0);//对于单链表，头插法效率较高
	}
	return 0;
}



/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
int LGraph_RemoveEdge(LGraph* graph, int v1, int v2)
{
	TLGraph* tGraph = (TLGraph*)graph;
	int condition = (tGraph != NULL);
	int ret = 0;
	condition = condition && (v1 >= 0) && (v1 < tGraph->count);
	condition = condition && (v2 >= 0) && (v2 < tGraph->count);


	if (condition){
		TListNode* node = NULL;
		int i = 0;

		for (i = 0; i < LinkList_Length(tGraph->la[v1]);i++){//遍历链表的每一个节点
			node = (TListNode*)LinkList_Get(tGraph->la[v1],i);
			if (node->v == v2){//判断是不是要找的节点
				ret = node->w;
				LinkList_Delete(tGraph->la[v1],i);
				free(node);
				break;
			}
		}
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
int LGraph_GetEdge(LGraph* graph, int v1, int v2)
{
	TLGraph* tGraph = (TLGraph*)graph;
	int condition = (tGraph != NULL);
	int ret = 0;
	condition = condition && (v1 >= 0) && (v1 < tGraph->count);
	condition = condition && (v2 >= 0) && (v2 < tGraph->count);
	if (condition){
		TListNode* node = NULL;
		int i = 0;

		for (i = 0; i < LinkList_Length(tGraph->la[v1]); i++){//遍历链表的每一个节点
			node = (TListNode*)LinkList_Get(tGraph->la[v1], i);
			if (node->v == v2){//判断是不是要找的节点
				ret = node->w;
				break;
			}
		}
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
int LGraph_TD(LGraph* graph, int v)
{
	TLGraph* tGraph = (TLGraph*)graph;
	int condition = (tGraph != NULL);
	int ret = 0;
	condition = condition && (v >= 0) && (v < tGraph->count);

	if (condition){
		int i = 0;
		int j = 0;


		/*求入度*/
		for (i = 0; i < tGraph->count;i++){//遍历链表数组
			for (j = 0;j < LinkList_Length(tGraph->la[i]);j++){//遍历每一个链表的每一个节点
				TListNode* node = (TListNode*)LinkList_Get(tGraph->la[i], j);
				if (node->v == v){
					ret++;
				}
			}
		}
		/*求出度，再加上之前求出的入度*/
		ret += LinkList_Length(tGraph->la[v]);
	}
	return ret;
}


/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
int LGraph_VertexCount(LGraph* graph)
{
	TLGraph* tGraph = (TLGraph*)graph;
	
	int ret = 0;
	if (tGraph != NULL){
		ret = tGraph->count;
	}
	
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明:图的边数就是所有顶点的出度之和或者入度之和
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
int LGraph_EdgeCount(LGraph* graph)
{
	TLGraph* tGraph = (TLGraph*)graph;
	int ret = 0;
	if (tGraph != NULL){
		int i = 0;
		for (i = 0; i < tGraph->count;i++){
			ret += LinkList_Length(tGraph->la[i]);
		}
	}
	return ret;
}

/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void LGraph_DFS(LGraph* graph, int v, LGraph_printf* pFunc)
{
	TLGraph* tGraph = (TLGraph*)graph;
	int condition = (tGraph != NULL);
	int* visited = NULL;
	condition = condition && (v >= 0) && (v < tGraph->count);
	condition = condition && (pFunc != NULL);
	condition = condition && ((visited = (int*)calloc(tGraph->count,sizeof(int))) != NULL);

	if (condition){
		int i = 0;
		recursive_dfs(tGraph, v, visited, pFunc);//表示当V还有相邻的节点未访问时继续深度遍历相邻节点

		for (i = 0; i < tGraph->count;i++){//表示当v的所有相邻节点已经被访问过，但是图中还有其他节点虽然不与V相邻，										//但还未访问过
			if (!visited[i]){
				recursive_dfs(tGraph, i, visited, pFunc);
			}
		}
	}

	free(visited);

}


/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void LGraph_BFS(LGraph* graph, int v, LGraph_printf* pFunc)
{
	TLGraph* tGraph = (TLGraph*)graph;
	int condition = (tGraph != NULL);
	int* visited = NULL;
	condition = condition && (v >= 0) && (v < tGraph->count);
	condition = condition && (pFunc != NULL);
	condition = condition && ((visited = (int*)calloc(tGraph->count, sizeof(int))) != NULL);

	if (condition){
		int i = 0;
		recursive_bfs(tGraph, v, visited, pFunc);//表示当V还有相邻的节点未访问时继续深度遍历相邻节点

		for (i = 0; i < tGraph->count; i++){//表示当v的所有相邻节点已经被访问过，但是图中还有其他节点虽然不与V相邻，										//但还未访问过
			if (!visited[i]){
				recursive_bfs(tGraph, i, visited, pFunc);
			}
		}
	}

	free(visited);
}
/**********************************************************************
*功能描述：
*输入参数：
*输出参数：
*返回值：
*其它说明：
*修改日期                   版本号          修改人        修改内容
* ------------------------------------------------------------------------------------------------------
* YYYYLLDD            XXX             Name            YYY
***********************************************************************/
void LGraph_Display(LGraph* graph, LGraph_printf* pFunc)
{
	TLGraph* tGraph = (TLGraph*)graph;
	if ((tGraph != NULL) && (pFunc != NULL)){
		int i = 0;
		int j = 0;


		for (i = 0; i < tGraph->count;i++){
			printf("%d:",i);
			pFunc(tGraph->v[i]);
			printf(" ");
		}
		printf("\n");
		for (i = 0; i < tGraph->count; i++){
			for (j = 0; j < LinkList_Length(tGraph->la[i]);j++){
				
				TListNode* node = (TListNode*)LinkList_Get(tGraph->la[i],j);
				printf("<");
				pFunc(tGraph->v[i]);
				printf(",");
				pFunc(tGraph->v[node->v]);
				printf(",%d",node->w);
				printf(">");
				printf(" ");
			
			}
		}
		printf("\n");
	}
}

测试文件

#include <stdio.h>
#include <stdlib.h>
#include "LGraph.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void print_data(LVertex* v)
{
	printf("%s", (char*)v);
}

int main(int argc, char *argv[])
{
	LVertex* v[] = { "A", "B", "C", "D", "E", "F" };
	LGraph* graph = LGraph_Create(v, 6);

	LGraph_AddEdge(graph, 0, 1, 1);
	LGraph_AddEdge(graph, 0, 2, 1);
	LGraph_AddEdge(graph, 0, 3, 1);
	LGraph_AddEdge(graph, 1, 5, 1);
	LGraph_AddEdge(graph, 1, 4, 1);
	LGraph_AddEdge(graph, 2, 1, 1);
	LGraph_AddEdge(graph, 3, 4, 1);
	LGraph_AddEdge(graph, 4, 2, 1);

	LGraph_Display(graph, print_data);

	LGraph_DFS(graph, 0, print_data);
	printf("\n");
	LGraph_BFS(graph, 0, print_data);
	printf("\n");
	LGraph_Destroy(graph);
	system("PAUSE");
	return 0;
}