数据结构之图的邻接矩阵存储

一、图的定义

图是由顶点的又穷非空集合和顶点之间边的集合组成的们通常表示为G(V,E)，其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
图的临界矩阵存储：用两个数组来表示图。一个一维数组存储图中顶点信息，一个二维数组(称为邻接矩阵)存储图中的边或弧的信息。

二、具体函数

1.结构体的定义

/*队列的结构体定义*/
typedef struct GraphNodeQueue
{
	int* nodes;
	int front;
	int rear;
}GraphNodeQueue,*QueuePtr;

/*图的结构体定义*/
typedef struct Graph
{
	int** connections;
	int numNodes;
}*GraphPtr;

2.初始化

/*队列的初始化*/
QueuePtr initQueue()
{
	QueuePtr resultQueuePtr=(QueuePtr)malloc(sizeof(struct GraphNodeQueue));
	resultQueuePtr->nodes=(int*)malloc(sizeof(int)*QUEUE_SIZE);
	resultQueuePtr->front=0;
	resultQueuePtr->rear=1;
	return resultQueuePtr;
}

/*图中判断访问数组初始化*/
void initTranverse(GraphPtr paraGraphPtr)
{
	int i;
	visitedPtr=(int*)malloc(sizeof(int)*paraGraphPtr->numNodes);

	for(i=0;i<paraGraphPtr->numNodes;i++)
	{
		visitedPtr[i]=0;/*初始所有顶点都是未访问过状态*/
	}
}

/*图的初始化*/
GraphPtr initGraph(int paraSize,int** paraData)
{
	int i,j;
	GraphPtr resultPtr=(GraphPtr)malloc(sizeof(Graph));
	resultPtr->numNodes=paraSize;
	resultPtr->connections=(int**)malloc(sizeof(int*)*paraSize);
	for(i=0;i<paraSize;i++)
	{
		resultPtr->connections[i]=(int*)malloc(sizeof(int)*paraSize);
		for(j=0;j<paraSize;j++)
		{
			resultPtr->connections[i][j]=paraData[i][j];
		}
	}
	return resultPtr;
}

3.判断队列是否为空

bool isQueueEmpty(QueuePtr paraQueuePtr)
{
	if((paraQueuePtr->front+1)%QUEUE_SIZE==paraQueuePtr->rear)
	{
		return true;
	}

	return false;
}

4.入队列以及出队列的实现

void enqueue(QueuePtr paraQueuePtr,int paraNode)
{
	if((paraQueuePtr->rear+1)%QUEUE_SIZE==paraQueuePtr->front%QUEUE_SIZE)
	{
		printf("ERROR,trying to enqueue %d.queue full.\r\n",paraNode);
		return ;
	}
	paraQueuePtr->nodes[paraQueuePtr->rear]=paraNode;
	paraQueuePtr->rear=(paraQueuePtr->rear+1)%QUEUE_SIZE;
}

int dequeue(QueuePtr paraQueuePtr)
{
	if(isQueueEmpty(paraQueuePtr))
	{
		printf("Error,empty queue\r\n");
		return NULL;
	}
	paraQueuePtr->front=(paraQueuePtr->front+1)%QUEUE_SIZE;

	return paraQueuePtr->nodes[paraQueuePtr->front];
}

5.深度优先遍历

void depthFirstTranverse(GraphPtr paraGraphPtr,int paraNode)
{
	int i;

	visitedPtr[paraNode]=1;
	printf("%d\t",paraNode);

	for(i=0;i<paraGraphPtr->numNodes;i++)
	{
		if(!visitedPtr[i])
		{
			if(paraGraphPtr->connections[paraNode][i])
			{
				depthFirstTranverse(paraGraphPtr,i);
			}
		}
	}
}

6.广度优先遍历

void widthFirstTranverse(GraphPtr paraGraphPtr,int paraStart)
{
	int i=0,j,tempNode;
	QueuePtr tempQueuePtr=initQueue();/*初始化一辅助用队列*/
	printf("%d\t",paraStart);
	visitedPtr[paraStart]=1;
	enqueue(tempQueuePtr,paraStart);
	while(!isQueueEmpty(tempQueuePtr))
	{
		tempNode=dequeue(tempQueuePtr);
		visitedPtr[tempNode]=1;

		i++;
		for(j=0;j<paraGraphPtr->numNodes;j++)
		{
			if(visitedPtr[j])
			continue;

			if(paraGraphPtr->connections[tempNode][j]==0)
			continue;

			printf("%d\t",j);
			visitedPtr[j]=1;/*设置当前顶点访问过*/
			enqueue(tempQueuePtr,j);/*此顶点入队列*/
		}
	}
}

三、具体代码实现

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

#define QUEUE_SIZE 10

int* visitedPtr;

typedef struct GraphNodeQueue
{
	int* nodes;
	int front;
	int rear;
}GraphNodeQueue,*QueuePtr;

typedef struct Graph
{
	int** connections;
	int numNodes;
}*GraphPtr;

QueuePtr initQueue()
{
	QueuePtr resultQueuePtr=(QueuePtr)malloc(sizeof(struct GraphNodeQueue));
	resultQueuePtr->nodes=(int*)malloc(sizeof(int)*QUEUE_SIZE);
	resultQueuePtr->front=0;
	resultQueuePtr->rear=1;
	return resultQueuePtr;
}

bool isQueueEmpty(QueuePtr paraQueuePtr)
{
	if((paraQueuePtr->front+1)%QUEUE_SIZE==paraQueuePtr->rear)
	{
		return true;
	}

	return false;
}

void enqueue(QueuePtr paraQueuePtr,int paraNode)
{
	if((paraQueuePtr->rear+1)%QUEUE_SIZE==paraQueuePtr->front%QUEUE_SIZE)
	{
		printf("ERROR,trying to enqueue %d.queue full.\r\n",paraNode);
		return ;
	}
	paraQueuePtr->nodes[paraQueuePtr->rear]=paraNode;
	paraQueuePtr->rear=(paraQueuePtr->rear+1)%QUEUE_SIZE;
}

int dequeue(QueuePtr paraQueuePtr)
{
	if(isQueueEmpty(paraQueuePtr))
	{
		printf("Error,empty queue\r\n");
		return NULL;
	}
	paraQueuePtr->front=(paraQueuePtr->front+1)%QUEUE_SIZE;

	return paraQueuePtr->nodes[paraQueuePtr->front];
}

GraphPtr initGraph(int paraSize,int** paraData)
{
	int i,j;
	GraphPtr resultPtr=(GraphPtr)malloc(sizeof(Graph));
	resultPtr->numNodes=paraSize;
	resultPtr->connections=(int**)malloc(sizeof(int*)*paraSize);
	for(i=0;i<paraSize;i++)
	{
		resultPtr->connections[i]=(int*)malloc(sizeof(int)*paraSize);
		for(j=0;j<paraSize;j++)
		{
			resultPtr->connections[i][j]=paraData[i][j];
		}
	}
	return resultPtr;
}

void initTranverse(GraphPtr paraGraphPtr)
{
	int i;
	visitedPtr=(int*)malloc(sizeof(int)*paraGraphPtr->numNodes);

	for(i=0;i<paraGraphPtr->numNodes;i++)
	{
		visitedPtr[i]=0;/*初始所有顶点都是未访问过状态*/
	}
}

void depthFirstTranverse(GraphPtr paraGraphPtr,int paraNode)
{
	int i;

	visitedPtr[paraNode]=1;/*已经访问该邻接顶点*/
	printf("%d\t",paraNode);

	for(i=0;i<paraGraphPtr->numNodes;i++)
	{
		if(!visitedPtr[i])/*对未访问过的顶点调用该函数*/
		{
			if(paraGraphPtr->connections[paraNode][i])
			{
				depthFirstTranverse(paraGraphPtr,i);
			}
		}
	}
}

void widthFirstTranverse(GraphPtr paraGraphPtr,int paraStart)
{
	int i=0,j,tempNode;
	QueuePtr tempQueuePtr=initQueue();/*初始化一辅助用队列*/
	printf("%d\t",paraStart);
	visitedPtr[paraStart]=1;
	enqueue(tempQueuePtr,paraStart);
	while(!isQueueEmpty(tempQueuePtr))
	{
		tempNode=dequeue(tempQueuePtr);
		visitedPtr[tempNode]=1;

		i++;
		for(j=0;j<paraGraphPtr->numNodes;j++)
		{
			if(visitedPtr[j])
			continue;

			if(paraGraphPtr->connections[tempNode][j]==0)
			continue;

			printf("%d\t",j);
			visitedPtr[j]=1;/*设置当前顶点访问过*/
			enqueue(tempQueuePtr,j);/*此顶点入队列*/
		}
	}
}

void testGraphTranverse()
{
	int i,j;
	int myGraph[5][5]={
		{0,1,0,1,1},
		{1,0,1,0,1},
		{0,1,0,1,1},
		{1,0,1,0,0},
		{1,1,1,0,0}
	};
	int** tempPtr;
	printf("Preparing data\r\n");

	tempPtr=(int**)malloc(5*sizeof(int*));
	for(i=0;i<5;i++)
	{
		tempPtr[i]=(int*)malloc(sizeof(int)*5);
	}

	for(i=0;i<5;i++)
	{
		for(j=0;j<5;j++)
		{
			tempPtr[i][j]=myGraph[i][j];
		}
	}

	printf("Data ready\r\n");

	GraphPtr tempGraphPtr=initGraph(5,tempPtr);
	printf("num nodes =%d \r\n",tempGraphPtr->numNodes);
	printf("Graph initialized\r\n");

	printf("Depth first visit:\r\n");
	initTranverse(tempGraphPtr);
	depthFirstTranverse(tempGraphPtr,4);

	printf("\r\nWidth first visit:\r\n");
	initTranverse(tempGraphPtr);
	widthFirstTranverse(tempGraphPtr,4);
}

int main()
{
	testGraphTranverse();
	return 0;
}

四、测试样例输出

Preparing data
Data ready
num nodes =5
Graph initialized
Depth first visit:
4 0 1 2 3
Width first visit:
4 0 1 2 3