数据结构 C 图的遍历

"C

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>
#define QUEUE_SIZE 10

int* visitedPtr;
/**N
 * A queue with a number of indices.
 */
typedef struct GraphNodeQueue{
    int* nodes;
    int front;
    int rear;
}GraphNodeQueue, *QueuePtr;

QueuePtr initQueue(){
    QueuePtr resultQueuePtr = (QueuePtr)malloc(sizeof(struct GraphNodeQueue));
    resultQueuePtr->nodes = (int*)malloc(QUEUE_SIZE * sizeof(int));
    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){
    //printf("front = %d, rear = %d.\r\n", paraQueuePtr->front, paraQueuePtr->rear);
    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;
    //printf("enqueue %d ends.\r\n", paraNode);
}

int dequeue(QueuePtr paraQueuePtr){
    if (isQueueEmpty(paraQueuePtr)) {
        printf("Error, empty queue\r\n");
        return -1;
    }

    paraQueuePtr->front = (paraQueuePtr->front + 1) % QUEUE_SIZE;
    //printf("dequeue %d ends.\r\n", paraQueuePtr->nodes[paraQueuePtr->front]);
    return paraQueuePtr->nodes[paraQueuePtr->front];
}

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

//void deepFirst(GraphPtr paraGraphPtr, int paraNode);
GraphPtr initGraph(int paraSize, int** paraData) {
    int i, j;
    GraphPtr resultPtr = (GraphPtr)malloc(sizeof(struct Graph));
    resultPtr -> numNodes = paraSize;
    //resultPtr -> connections = (int**)malloc(paraSize * paraSize * sizeof(int));
    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){
    //Use a queue to manage the pointers
    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(5 * sizeof(int*));
    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;
}
 

This is the code."

运行结果