DAY eleven 图的遍历和邻接表

图的遍历

总代码

#include
#include
 
int *visitedPtr;
 

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

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

 
int isQueueEmpty(QueuePtr paraQueuePtr) {
    if (paraQueuePtr->front == paraQueuePtr->rear) {
        return 1;
    }
    
    return 0;
}
 

 
void enqueue(QueuePtr paraQueuePtr, int paraNode) {
    if ((paraQueuePtr->rear + 1) % 10 == paraQueuePtr->front) {
        printf("Error, trying to enqueue %d. queue fulln", paraNode);
        return;
    }
    paraQueuePtr->nodes[paraQueuePtr->rear] = paraNode;
    paraQueuePtr->rear = (paraQueuePtr->rear + 1) % 10;
}
 

 
int dequeue(QueuePtr paraQueuePtr) {
    int tempValue;
    if (isQueueEmpty(paraQueuePtr) == 1) {
        printf("Error, empty queuen");
        return 0;
    }
    
    tempValue = paraQueuePtr->nodes[paraQueuePtr->front];
    paraQueuePtr->front = (paraQueuePtr->front + 1) % 10;
    
    return tempValue;
}
 

 
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(sizeof(int*));
    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("%dt", paraNode);
    
    for (i = 0; i < paraGraphPtr->numNodes; i ++) {
        if (visitedPtr[i] == 0) {
            if (paraGraphPtr->connections[paraNode][i] == 1) {
                depthFirstTranverse(paraGraphPtr, i);
            }
        }
    }
}
 

 
void widthFirstTranverse(GraphPtr paraGraphPtr, int paraStart) {
    int i, j, tempNode;
    i = 0;
    QueuePtr tempQueuePtr = initQueue();
    printf("%dt", paraStart);
    visitedPtr[paraStart] = 1;
    enqueue(tempQueuePtr, paraStart);
    while (isQueueEmpty(tempQueuePtr) == 0) {
        tempNode = dequeue(tempQueuePtr);
        visitedPtr[tempNode] = 1;
        
        i ++;
        
        for (j = 0; j < paraGraphPtr->numNodes; j ++) {
            if (visitedPtr[j] == 1) {
                continue;
            }
            
            if (paraGraphPtr->connections[tempNode][j] == 0) {
                continue;
            }
            
            printf("%dt", 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 datan");
    
    tempPtr = (int**)malloc(sizeof(int*) * 5);
    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 readyn");
    
    GraphPtr tempGraphPtr = initGraph(5, tempPtr);
    printf("num nodes = %dn", tempGraphPtr->numNodes);
    printf("Graph initializedn");
    
    printf("Depth first visit:n");
    initTranverse(tempGraphPtr);
    depthFirstTranverse(tempGraphPtr, 4);
    
    printf("rnWidth first visit:n");
    initTranverse(tempGraphPtr);
    widthFirstTranverse(tempGraphPtr, 4);
}
 
int main() {
    testGraphTranverse();
    return 0;
} 

运行结果

邻接表

总代码

#include
#include
 
int *visitedPtr;
 

 
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(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;
}
 

 
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) * 10);
    resultQueuePtr->front = 0;
    resultQueuePtr->rear = 0;
    return resultQueuePtr;
}
 

 
int isQueueEmpty(QueuePtr paraQueuePtr){
    if (paraQueuePtr->front == paraQueuePtr->rear) {
        return 1;
    }
 
    return 0;
}
 

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

 
int dequeue(QueuePtr paraQueuePtr){
    int tempValue;
    if (isQueueEmpty(paraQueuePtr) == 1) {
        printf("Error, empty queuen");
        return 0;
    }
    
    tempValue = paraQueuePtr->nodes[paraQueuePtr->front];
    paraQueuePtr->front = (paraQueuePtr->front + 1) % 10;
 
    return tempValue;
}
 

 
typedef struct AdjacencyNode{
    int colum;
    struct AdjacencyNode *next;
} AdjacencyNode, *AdjacentNodePtr;
 

 
typedef struct AdjacencyList{
    int numNodes;
    AdjacencyNode *headers;
} AdjacencyList, *AdjacencyListPtr;
 

 
AdjacencyListPtr graphToAdjacentList(GraphPtr paraPtr) {
    int i, j, tempNum;
    AdjacentNodePtr p, q;
    tempNum = paraPtr->numNodes;
    AdjacencyListPtr resultPtr = (AdjacencyListPtr)malloc(sizeof(AdjacencyList));
    resultPtr->numNodes = tempNum;
    resultPtr->headers = (AdjacentNodePtr)malloc(sizeof(AdjacencyNode) * tempNum);
    
    for (i = 0; i < tempNum; i ++) {
        p = &(resultPtr->headers[i]);
        
        for (j = 0; j < tempNum; j ++) {
            if (paraPtr->connections[i][j] > 0) {
                q = (AdjacentNodePtr)malloc(sizeof(AdjacencyNode));
                q->colum = j;
                q->next = NULL;
                
                p->next = q;
                p = q;
            }
        }
    }
    
    return resultPtr; 
}
 
void printAdjacentList(AdjacencyListPtr paraPtr) {
    int i;
    AdjacentNodePtr p;
    int tempNum = paraPtr->numNodes;
    
    printf("This is the graph:n");
    for (i = 0; i < tempNum; i ++) {
        p = paraPtr->headers[i].next;
        while (p != NULL) {
            printf("%d, ", p->colum);
            p = p->next;
        }
        printf("n");
    }
}
 

 
void widthFirstTranverse(AdjacencyListPtr paraListPtr, int paraStart) {
    printf("width firstn");
    
    int i, j, tempNode;
    AdjacentNodePtr p;
    i = 0;
    
    visitedPtr = (int*)malloc(sizeof(int) * paraListPtr->numNodes);
    
    for (i = 0; i < paraListPtr->numNodes; i ++) {
        visitedPtr[i] = 0;
    }
    
    QueuePtr tempQueuePtr = initQueue();
    printf("%dt", paraStart);
    visitedPtr[paraStart] = 1;
    enqueue(tempQueuePtr, paraStart);
    
    while (isQueueEmpty(tempQueuePtr) == 0) {
        tempNode = dequeue(tempQueuePtr);
        p = paraListPtr->headers[tempNode].next;
        
        for (; p != NULL; p = p->next) {
            j = p->colum;
            
            if (visitedPtr[j] == 1) {
                continue;
            }
            
            printf("%dt", 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 datan");
    
    tempPtr = (int**)malloc(sizeof(int*) * 5);
    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 readyn");
    
    GraphPtr tempGraphPtr = initGraph(5, tempPtr);
    AdjacencyListPtr tempListPtr = graphToAdjacentList(tempGraphPtr);
    
    printAdjacentList(tempListPtr);
    
    widthFirstTranverse(tempListPtr, 4);
}
 
int main() {
    testGraphTranverse();
    return 0;
} 

运行结果