数据结构作业16--图的遍历

代码本体

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
 
#define QUEUE_SIZE 10
 
int* visitedPtr;
 
typedef struct GraphNodeQueue
{
	int *nodes;
	int front;
	int rear;
}GraphNodeQueue,*QueuePtr;
 
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 -1;
	}
	
	paraQueuePtr->front =(paraQueuePtr->front+1)%QUEUE_SIZE;
	
	return paraQueuePtr->nodes[paraQueuePtr->front];
}
 
typedef struct Graph
{
	int** connections;
	int numNodes;
}*GraphPtr;
 
GraphPtr initGraph(int paraSize,int** paraData)
{
	int i,j;
	GraphPtr resultPtr=(GraphPtr)malloc(sizeof(struct Graph));
	resultPtr->numNodes =paraSize;
	
	resultPtr->connections =(int**)malloc(paraSize*sizeof(int*));
	for(i=0;i<paraSize;i++)
	{
		resultPtr->connections[i]=(int*)malloc(paraSize*sizeof(int));
		for(j=0;j<paraSize;j++)
		{
			resultPtr->connections[i][j]=paraData[i][j];
		}
	}
	
	return resultPtr;
}
 
void initTranverse(GraphPtr paraGraphPtr)
{
	int i;
	
	visitedPtr=(int*)malloc(paraGraphPtr->numNodes *sizeof(int));
	
	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,j,tempNode;
	i=0;
	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,0},
		{1,0,1,0,1},
		{0,1,0,1,1},
		{1,0,1,0,0},
		{0,1,1,0,0}
	};
	int** tempPtr;
	printf("Preparing data\r\n");
	
	tempPtr=(int**)malloc(sizeof(int*)*5);
	for(i=0;i<5;i++)
	{
		tempPtr[i]=(int*)malloc(5*sizeof(int));
	}
	
	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 1;
}

运行结果

代码说明

1. 深度优先用递归.
2. 广度优先用栈, 其实和二叉树的遍历很像, 队列也是从那边抄过来改巴改巴就可以了.