13 邻接矩阵

一、图的定义

     若E是无向边(简称边)的有限集合时，则图G为无向图。边是顶点的无序对，记为(v, w)或(w,v),因为(v,w)=(w,v), 其中v,w是顶点。可以说顶点w和顶点v互为邻接点。边(v, w)依附于顶点w和v，或者说边(v, w)和顶点v, w相关联.

        

二、图的相关概念

简单图：不存在重复边，不存在顶点到自身的边

多重图：某两个结点之间的边数多于一条，又允许顶点通过同一条边和自己关联

 路径：顶点到顶点之间的一条路径，路径是指顶点序列

 简单路径：在路径序列中，顶点不重复出现的路径

回路：第一个顶点和最后一个顶点相同的路径

简单回路：除第一个顶点和最后一个顶点外，其余顶点不重复出现的回路

三、相关代码

3.1 结构体的定义

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

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

3.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.3 判断队列是否为空

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

	return false;
}

3.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];
}

3.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);
			}
		}
	}
}

3.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);/*此顶点入队列*/
		}
	}
}