学習目標:
この 2 つを確認してください
隣接リストはグラフの圧縮ストレージに相当し、トラバーサルはグラフと同じです。
最小スパニング ツリーアルゴリズムと単一ソース最短パス アルゴリズムの違いは、わずか 2 行のコードです。
学習課題:
コードの説明:
(1) 隣接リストと幅優先トラバーサル
- キュー側のコードは 7.1 からコピーされています。
- グラフを構築するコードもすぐに入手できます。
- マトリックス形式を隣接リスト形式に変換します。
- For は、隣接するものを横断するときに使用されます。これは、本質的には「しばらく」です。
(2)プリムのアルゴリズムとダイクストラのアルゴリズム
- グラフ ストレージとネットワーク ストレージはどちらも行列を使用でき、前者はブール値を格納し、後者は重みを格納します。
- Prim は道路建設に対応する最小スパニング ツリーであり、ダイクストラのアルゴリズムは単一ソースの最短パスであり、地図のルーティングに適用されます。
- O(n2) の時間計算量は、貪欲な選択戦略と高度な前処理によって実現されます。
- 隣接リストを使用すると高速になります。
- 実際、時間計算量は O(nlogn) に最適化できます。Zhang Xingyi のブログを参照してください。
勉強の時間：
2022.5.19
1 データ構造 C コード 7.2: 隣接リストと幅優先トラバーサル
1.1 すべてのコード
#include <stdio.h>
#include <malloc.h>
#define MAXSIZE 10
int* visited;
typedef struct graph
{
int** connections;
int numNodes;
}*graphPtr;
typedef struct graphQueue
{
int *node;
int front;
int rear;
}*graphQueuePtr;
typedef struct AdjacencyNode
{
int column;
struct AdjacencyNode* next;
}*AdjacencyNodePtr;
typedef struct AdjacencyList
{
int numNodes;
struct AdjacencyNode* headers;
}*AdjacencyListPtr;
graphQueuePtr queueInit()
{
graphQueuePtr resultQueue = (graphQueuePtr)malloc(sizeof(struct graphQueue));
resultQueue->node = (int*)malloc(MAXSIZE * sizeof(int));
resultQueue->front = 0;
resultQueue->rear = 0;
return resultQueue;
}
void enqueue(graphQueuePtr paraQueue,int paraData)
{
if((paraQueue->rear + 1) % MAXSIZE == (paraQueue->front) % MAXSIZE)
{
printf("队列满了，无法入队！\n");
return ;
}
paraQueue->node[(paraQueue->rear) % MAXSIZE] = paraData;
paraQueue->rear = (paraQueue->rear + 1) % MAXSIZE;
}
int dequeue(graphQueuePtr paraQueue)
{
if(paraQueue->front == paraQueue->rear)
{
printf("队列为空，无法出队！\n");
return 0;
}
int temp = paraQueue->node[(paraQueue->front) % MAXSIZE];
paraQueue->front = (paraQueue->front + 1) % MAXSIZE;
return temp;
}
void visitedInit(AdjacencyListPtr paraPtr)
{
int i;
visited = (int*)malloc(paraPtr->numNodes * sizeof(int));
for(i = 0;i < paraPtr->numNodes;i ++)
{
visited[i] = 0;
}
}
/**
* @brief 初始化图
*
* @param paraConnections
* @param paraNumNodes
*
* @return
*/
graphPtr graphInit(int **paraConnections,int paraNumNodes)
{
int i,j;
graphPtr resultGraph = (graphPtr)malloc(sizeof(struct graph));
resultGraph->numNodes = paraNumNodes;
//这里如何给二维数组动态分配空间如果不明白可以参考我以前的二维数组文章
resultGraph->connections = (int**)malloc(resultGraph->numNodes * sizeof(int*));
for(i = 0;i < resultGraph->numNodes;i ++)
{
resultGraph->connections[i] = (int*)malloc(resultGraph->numNodes * sizeof(int));
}
for(i = 0;i < resultGraph->numNodes;i ++)
for(j = 0;j < resultGraph->numNodes;j ++)
{
resultGraph->connections[i][j] = paraConnections[i][j];
}
return resultGraph;
}
/**
* @brief 把图转化为接邻列表
*
* @param paraGraph
*
* @return
*/
AdjacencyListPtr graphToAdjacency(graphPtr paraGraph)
{
int i,j;
int tempNodes = paraGraph->numNodes;
//分配空间
AdjacencyListPtr resultList = (AdjacencyListPtr)malloc(sizeof(struct AdjacencyList));
resultList->numNodes = tempNodes;
resultList->headers = (AdjacencyNodePtr)malloc(tempNodes * sizeof(struct AdjacencyNode));
/*p是用来跟踪当前位置的，所有不用分配空间q是用来开辟新的结点的，要分配空间*/
AdjacencyNodePtr p,q;
for(i = 0;i < tempNodes;i ++)
{
//每一次都指向下一个元素，即下一个链表的头结点
p = &(resultList->headers[i]);
p->column = -1;
p->next = NULL;
for(j = 0;j < tempNodes;j ++)
{
if(paraGraph->connections[i][j] == 1)
{
q = (AdjacencyNodePtr)malloc(sizeof(struct AdjacencyNode));
q->column = j;
q->next = NULL;
//链接过去，并让p跟踪
p->next = q;
p = q;
}
}
}
return resultList;
}
/**
* @brief 邻接列表普通遍历
*
* @param paraList
*/
void printAdjacencyList(AdjacencyListPtr paraList)
{
printf("打印邻接列表:\n");
//用p来跟踪，一个一个打印就好
AdjacencyNodePtr p;
int i;
for(i = 0; i < paraList->numNodes;i ++)
{
//当p跟踪玩当前链表后，记得要把p指向下一个链表头结点的next
p = paraList->headers[i].next;
while(p != NULL)
{
printf("%d ",p->column);
p = p->next;
}
printf("\n");
}
}
/**
* @brief 邻接列表广度优先搜索，和图的广度优先搜索一样
*
* @param paraList
* @param paraNum
*/
void wideTranverse(AdjacencyListPtr paraList,int paraNum)
{
printf("邻接列表的广度优先搜索:\n");
int temp;
//初始化visited
visitedInit(paraList);
//创建队列
graphQueuePtr tempQueue = queueInit();
enqueue(tempQueue,paraNum);
visited[paraNum] = 1;
printf("%d ",paraNum);
//还是用p跟踪
AdjacencyNodePtr p;
while(tempQueue->front != tempQueue->rear)
{
temp = dequeue(tempQueue);
//出队了就让p指向对应的这个链表的头部的next
p = paraList->headers[temp].next;
//p == NULL就代表这个链表循环完了
while(p != NULL)
{
//如果没被访问过，就直接入队
if(visited[p->column] == 0)
{
enqueue(tempQueue,p->column);
printf("%d ",p->column);
visited[p->column] = 1;
}
//注意这个要写在外面，无论是否被访问了都要往后走
p = p->next;
}
}
}
/**
* 广度遍历测试类
*/
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("准备数据\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("准备完毕\r\n");
graphPtr tempGraphPtr = graphInit(tempPtr,5);
AdjacencyListPtr tempListPtr = graphToAdjacency(tempGraphPtr);
printAdjacencyList(tempListPtr);
wideTranverse(tempListPtr, 4);
}
int main(){
testGraphTranverse();
return 1;
}
1.2 試験結果
准备数据
准备完毕
打印邻接列表:
1 3
0 2 4
1 3 4
0 2
1 2
邻接列表的广度优先搜索:
4 1 2 0 327.3: プリムのアルゴリズムとダイクストラのアルゴリズム
2.1 すべてのコード
#include <stdio.h>
#include <malloc.h>
//表示无穷
#define MAX 100000
typedef struct net
{
int **weights;
int numNode;
}*netPtr;
/**
* @brief 初始化图
*
* @param paraArray
* @param paraNodes
*
* @return
*/
netPtr netInit(int paraNodes,int **paraArray)
{
int i,j;
//全是动态的，都要malloc
netPtr resultNet = (netPtr)malloc(sizeof(struct net));
resultNet->weights = (int**)malloc(paraNodes*sizeof(int*));
for(i = 0;i < paraNodes;i ++)
{
resultNet->weights[i] = (int*)malloc(paraNodes*sizeof(int));
}
//纯纯拷贝
resultNet->numNode = paraNodes;
for(i = 0;i < paraNodes;i ++)
for(j = 0;j < paraNodes;j ++)
resultNet->weights[i][j] = paraArray[i][j];
return resultNet;
}
/**
* @brief Prim算法
*
* @param paraAlgorithm 后面一个参数单纯是为了选择用哪个算法而已
* @param paraNet
*/
void PrimOrDijkstra(netPtr paraNet,int paraAlgorithm)
{
int i,j,tempBestNode,minDistance,resultCost;
int *visited,*parent,*distant;
int numNodes = paraNet->numNode;
//这里是用来存放是否访问过、父节点、最短距离的数组
visited = (int*)malloc(sizeof(int) * paraNet->numNode);
parent = (int*)malloc(sizeof(int) * paraNet->numNode);
distant = (int*)malloc(sizeof(int) * paraNet->numNode);
//我们默认起始点为0开始构建。
int source = 0;
//初始化
for(i = 0;i < paraNet->numNode;i ++)
{
visited[i] = 0;
parent[i] = source;
distant[i] = paraNet->weights[source][i];
}
distant[source] = 0;
visited[source] = 1;
parent[source] = -1;
//算法开始，第一个结点已经在网中了，我们只需循环n-1次
for(i = 0;i < numNodes-1;i ++)
{
/*第一步，即第一个循环，实现要找到与目前结点
项链且路径最短的那个结点为最佳结点*/
minDistance = MAX;
for(j = 0;j < numNodes;j ++)
{
if(distant[j] < minDistance && visited[j] == 0)
{
minDistance = distant[j];
tempBestNode = j;
}
}
//找到之后就表示他以及被放问过了，即已经入网了
visited[tempBestNode] = 1;
/*第二步，是最佳结点要帮组其他结点了*/
for(j = 0;j < numNodes;j ++)
{
//在网中直接下一个
if(visited[j] == 1)
{
continue;
}
/*后面的话初始化的时候，我们把图里面的0表示不连通直接转换为MAX无穷大了
所有，无穷大即不连通的话直接下一个*/
if(paraNet->weights[tempBestNode][j] >= MAX)
{
continue;
}
//这里算法出现一点点分支 0是最短路径，1是最小生成树
if(paraAlgorithm == 0)
{
/*最短路径呢，是这样的：如果从始结点到最佳结点加上最佳结点到j结点
这两者的距离比始节点直接到j结点的距离还要短，那么就肯定选第一种方法啊
所以说就开始改变到j的最小距离，改变j的父节点为当前最佳结点。*/
for(j = 0;j < numNodes;j ++)
{
if(distant[tempBestNode] + paraNet->weights[tempBestNode][j] < distant[j])
{
distant[j] = paraNet->weights[tempBestNode][j] + distant[tempBestNode];
parent[j] = tempBestNode;
}
}
}
if(paraAlgorithm == 1)
{
/*最小生成唯一不同的，是不用加上从始结点到最佳结点的距离了，我们要的是最小代价构建网
所以不用加上之前的距离了，有更小距离的就可以直接帮助*/
for(j = 0;j < numNodes;j ++)
{
if(paraNet->weights[tempBestNode][j] < distant[j])
{
distant[j] = paraNet->weights[tempBestNode][j];
parent[j] = tempBestNode;
}
}
}
}
}
printf("所有节点的父节点依次为: \n");
//打印父节点
for(i = 0; i < numNodes; i++)
{
printf("%d ", parent[i]);
}
printf("\n");
/**
* 俩算法的不同点
*/
if(paraAlgorithm == 0)
{
/*最短路径算法distant里面存储的就是0到每各结点的最短路径
所以直接打印就好*/
printf("所有节点的路径长度依次为：\n ");
for(i = 0; i < numNodes; i++)
{
printf("%d ", distant[i]);
}
}
if(paraAlgorithm == 1)
{
/*最小生成树里面distant存储的其实是每个结点到父节点的距离
，除了source，每个结点都有唯一一个父节点，所以把他们加起来就是
总的代价*/
resultCost = 0;
for(i = 0; i < numNodes; i++)
{
resultCost += distant[i];
printf("节点%d 的路径长度为 %d , 总路径长度为 %d\n", i, distant[i], resultCost);
}
printf("最后，总路径长度为 %d.\n ", resultCost);
}
printf("\r\n");
}
/**
* @brief 构建样本网
*
* @return
*/
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("准备数据\n");
tempPtr = (int**)malloc(numNodes * sizeof(int*));
for (i = 0; i < numNodes; i ++)
{
tempPtr[i] = (int*)malloc(numNodes * sizeof(int));
}
for (i = 0; i < numNodes; i ++)
{
for (j = 0; j < numNodes; j ++)
{
if (myGraph[i][j] == 0)
{
tempPtr[i][j] = MAX;
}
else
{
tempPtr[i][j] = myGraph[i][j];
}
}
}
printf("准备完毕\n");
netPtr resultNetPtr = netInit(numNodes, tempPtr);
return resultNetPtr;
}
/**
* @brief 测试类
*/
void testPrim()
{
netPtr tempNetPtr = constructSampleNet();
printf("=====Dijkstra 算法=====\n");
PrimOrDijkstra(tempNetPtr, 0);
printf("===== Prim 算法 =====\n");
PrimOrDijkstra(tempNetPtr, 1);
}
int main()
{
testPrim();
}
2.2 試験結果
准备数据
准备完毕
=====Dijkstra 算法=====
所有节点的父节点依次为:
-1 0 0 0 2 2
所有节点的路径长度依次为：
0 6 1 5 7 5
===== Prim 算法 =====
所有节点的父节点依次为:
-1 2 0 5 1 2
节点0 的路径长度为 0 , 总路径长度为 0
节点1 的路径长度为 5 , 总路径长度为 5
节点2 的路径长度为 1 , 总路径长度为 6
节点3 的路径长度为 2 , 总路径长度为 8
节点4 的路径长度为 3 , 总路径长度为 11
节点5 的路径长度为 4 , 总路径长度为 15
最后，总路径长度为 15.2.3 図
良い写真を使用しています [doge]
1. ダイクストラ アルゴリズムの距離配列は、0 から各ノードまでの最短パス長です。
2. Prim アルゴリズムの距離配列は、このノードから親ノードまでのパスの長さです。
