DAY twelve 普利姆算法和迪杰斯特拉算法

总代码

#include<stdio.h>
#include<stdlib.h>
 
/**
 *建立网
 */
 
typedef struct Net{
    int **weights;
    int numNodes;
} *NetPtr;
 
/**
 *初始化
 */
 
NetPtr initNet(int paraSize, int **paraData) {
    int i, j;
    NetPtr resultPtr = (NetPtr)malloc(sizeof(struct Net));
    resultPtr->numNodes = paraSize;
    
    resultPtr->weights = (int**)malloc(sizeof(int*) * paraSize);
    for (i = 0; i < paraSize; i ++) {
        resultPtr->weights[i] = (int*)malloc(sizeof(int) * sizeof(int));
        for (j = 0; j < paraSize; j ++) {
            resultPtr->weights[i][j] = paraData[i][j];
        }
    }
    
    return resultPtr;
}
 
/**
 *普利姆算法和迪杰斯特拉算法 
 */
 
int dijkstraOrPrim(NetPtr paraPtr, int paraAlgorithm) {
    int i, j, minDistance, tempBestNode, resultCost;
    int source = 0;
    int numNodes = paraPtr->numNodes;
    int *distanceArray = (int*)malloc(sizeof(int) * numNodes);
    int *parentArray = (int*)malloc(sizeof(int) * numNodes);
    int *visitedArray = (int*)malloc(sizeof(int) * numNodes);
    
    for (i = 0; i < numNodes; i ++) {
        distanceArray[i] = paraPtr->weights[source][i];
        parentArray[i] = source;
        visitedArray[i] = 0;
    }
    distanceArray[source] = 0;
    parentArray[source] = -1;
    visitedArray[source] = 1;
    
    tempBestNode = -1;
    for (i = 0; i < numNodes - 1; i ++) {
        minDistance = 10000;
        for (j = 0; j < numNodes; j ++) {
            if (visitedArray[j] == 1) {
                continue;
            }
            
            if (minDistance > distanceArray[j]) {
                minDistance = distanceArray[j];
                tempBestNode = j;
            }
        }
    
    visitedArray[tempBestNode] = 1;
    
    for (j = 0; j < numNodes; j ++) {
        if (visitedArray[j] == 1) {
            continue;
        }
        
        if (paraPtr->weights[tempBestNode][j] >= 10000) {
            continue;
        }
        
        if (paraAlgorithm == 0) {
            if (distanceArray[j] > distanceArray[tempBestNode] + paraPtr->weights[tempBestNode][j]) {
                distanceArray[j] = distanceArray[tempBestNode] + paraPtr->weights[tempBestNode][j];
                parentArray[j] = tempBestNode;
            }
        } else {
            if (distanceArray[j] > paraPtr->weights[tempBestNode][j]) {
                distanceArray[j] = paraPtr->weights[tempBestNode][j];
                parentArray[j] = tempBestNode;
            }
        }
    }
}
 
    printf("the parent of each node: \n");
    for (i = 0; i < numNodes; i ++) {
        printf("%d ", parentArray[i]);
    }
    printf("\n");
    
    if (paraAlgorithm == 0) {
        printf("From node 0, path length to all nodes are: ");
        for (i = 0; i < numNodes; i ++) {
            printf("%d (%d), ", i, distanceArray[i]);
        }
    } else {
        resultCost = 0;
        for (i = 0; i < numNodes; i ++) {
            resultCost += distanceArray[i];
            printf("cost of node %d is %d, total = %d\n", i, distanceArray[i], resultCost);
        }
        printf("Finally, the total cost is %d.\n", resultCost);
    }
    
    printf("\n");
    
    return resultCost;
}
 
/**
 *建立网
 */
 
NetPtr constructSampleNet() {
    int i, j;
    int myGraph[6][6] = {
        {0, 6, 1, 5, 0, 0},
        {6, 0, 5, 0, 3, 0},
        {1, 5, 0, 5, 6, 4},
        {5, 0, 5, 0, 0, 2},
        {0, 3, 6, 0, 0, 6},
        {0, 0, 4, 2, 6, 0}};
    int **tempPtr;
    int numNodes = 6;
    printf("PreParing data\n");
    
    tempPtr = (int**)malloc(sizeof(int*) * numNodes);
    for (i = 0; i < numNodes; i ++) {
        tempPtr[i] = (int*)malloc(sizeof(int) * numNodes);
    }
    
    for (i = 0; i < numNodes; i ++) {
        for (j = 0; j < numNodes; j ++) {
            if (myGraph[i][j] == 0) {
                tempPtr[i][j] = 10000;
            } else {
                tempPtr[i][j] = myGraph[i][j];
            }
        }
    }
    
    printf("Data ready\n");
    
    NetPtr resultNetPtr = initNet(numNodes, tempPtr);
    return resultNetPtr;
}
 
void testPrim() {
    NetPtr tempNetPtr = constructSampleNet();
    printf("=====Dijkstra algorithm=====\n");
    dijkstraOrPrim(tempNetPtr, 0);
    printf("=====Prim algorithm=====\n");
    dijkstraOrPrim(tempNetPtr, 1);
}
 
int main() {
    testPrim();
    return 0;
} 

运行结果