c/c++ 用普利姆（prim）算法構造最小生成樹

c/c++ 用普利姆（prim）算法構造最小生成樹

最小生成樹（Minimum Cost Spanning Tree）的概念：

​ 假設要在n個城市之間建立公路，則連通n個城市只需要n-1條線路。這時，自然會考慮，如何在最節省經費的前提下建立這個公路網絡。

​ 每2個城市之間都可以設置一條公路，相應地都要付出一定的經濟代價。n個城市之間，最多可以設置n(n-1)/2條線路，那么，如何在這些可能的線路中選擇n-1條，以使總的耗費最少？

普利姆（prim）算法的大致思路：

​ 大致思想是：設圖G頂點集合為U，首先任意選擇圖G中的一點作為起始點a，將該點加入集合V，再從集合U-V中找到另一點b使得點b到V中任意一點的權值最小，此時將b點也加入集合V；以此類推，現在的集合V={a，b}，再從集合U-V中找到另一點c使得點c到V中任意一點的權值最小，此時將c點加入集合V，直至所有頂點全部被加入V，此時就構建出了一顆MST。因為有N個頂點，所以該MST就有N-1條邊，每一次向集合V中加入一個點，就意味着找到一條MST的邊。

用圖示和代碼說明：

初始狀態：

設置2個數據結構：

lowcost[i]:表示以i為終點的邊的最小權值,當lowcost[i]=0說明以i為終點的邊的最小權值=0,也就是表示i點加入了MST

mst[i]:表示對應lowcost[i]的起點，即說明邊<mst[i],i>是MST的一條邊，當mst[i]=0表示起點i加入MST

我們假設V1是起始點，進行初始化（*代表無限大，即無通路）：

lowcost[2]=6，lowcost[3]=1，lowcost[4]=5，lowcost[5]=，lowcost[6]=

mst[2]=1，mst[3]=1，mst[4]=1，mst[5]=1，mst[6]=1，（所有點默認起點是V1）

明顯看出，以V3為終點的邊的權值最小=1，所以邊<mst[3],3>=1加入MST

此時，因為點V3的加入，需要更新lowcost數組和mst數組：

lowcost[2]=5，lowcost[3]=0，lowcost[4]=5，lowcost[5]=6，lowcost[6]=4

mst[2]=3，mst[3]=0，mst[4]=1，mst[5]=3，mst[6]=3

明顯看出，以V6為終點的邊的權值最小=4，所以邊<mst[6],6>=4加入MST

此時，因為點V6的加入，需要更新lowcost數組和mst數組：

lowcost[2]=5，lowcost[3]=0，lowcost[4]=2，lowcost[5]=6，lowcost[6]=0

mst[2]=3，mst[3]=0，mst[4]=6，mst[5]=3，mst[6]=0

明顯看出，以V4為終點的邊的權值最小=2，所以邊<mst[4],4>=4加入MST

此時，因為點V4的加入，需要更新lowcost數組和mst數組：

lowcost[2]=5，lowcost[3]=0，lowcost[4]=0，lowcost[5]=6，lowcost[6]=0

mst[2]=3，mst[3]=0，mst[4]=0，mst[5]=3，mst[6]=0

明顯看出，以V2為終點的邊的權值最小=5，所以邊<mst[2],2>=5加入MST

此時，因為點V2的加入，需要更新lowcost數組和mst數組：

lowcost[2]=0，lowcost[3]=0，lowcost[4]=0，lowcost[5]=3，lowcost[6]=0

mst[2]=0，mst[3]=0，mst[4]=0，mst[5]=2，mst[6]=0

很明顯，以V5為終點的邊的權值最小=3，所以邊<mst[5],5>=3加入MST

lowcost[2]=0，lowcost[3]=0，lowcost[4]=0，lowcost[5]=0，lowcost[6]=0

mst[2]=0，mst[3]=0，mst[4]=0，mst[5]=0，mst[6]=0

至此，MST構建成功，如圖所示：

mixSpanTree.h

#ifndef __mixspantree__
#define __mixspantree__

#include <stdio.h>
#include <malloc.h>
#include <assert.h>
#include <memory.h>

#define Default_vertex_size 20

#define T char//dai biao ding dian de lei xing
#define E int
#define MAX_COST 0x7FFFFFFF


typedef struct GraphMtx{
  int MaxVertices;//zui da ding dian shu liang]
  int NumVertices;//shi ji ding dian shu liang
  int NumEdges;//bian de shu lian

  T* VerticesList;//ding dian list
  int** Edge;//bian de lian jie xin xi, bu shi 0 jiu shi 1
}GraphMtx;

//chu shi hua tu
void init_graph(GraphMtx* gm);
//打印二維數組
void show_graph(GraphMtx* gm);
//插入頂點
void insert_vertex(GraphMtx* gm, T v);
//添加頂點間的線
void insert_edge(GraphMtx* gm, T v1, T v2, E cost);
//刪除頂點
void remove_vertex(GraphMtx* gm, T v);
//刪除頂點間的線
void remove_edge(GraphMtx* gm, T v1, T v2);
//摧毀圖
void destroy_graph(GraphMtx* gm);
//取得與v頂點有連線的第一個頂點
int getNeighbor(GraphMtx* gm, T v);
//取得與v1頂點，v1頂點之后的v2頂點的之后的有連線的第一個頂點
int getNextNeighbor(GraphMtx* gm, T v1, T v2);

//用prim算法作成最小樹
void minSpanTree_prim(GraphMtx* gm, T v);
//取得2個頂點間的權重
E getWeight(GraphMtx* g, int i1, int i2);

#endif

mixSpanTree.c

#include "mixSpanTree.h"

void init_graph(GraphMtx* gm){
  gm->MaxVertices = Default_vertex_size;
  gm->NumEdges = gm->NumVertices = 0;

  //kai pi ding dian de nei cun kong jian
  gm->VerticesList = (T*)malloc(sizeof(T) * (gm->MaxVertices));
  assert(NULL != gm->VerticesList);

  //創建二維數組
  //讓一個int的二級指針，指向一個有8個int一級指針的數組
  //開辟一個能存放gm->MaxVertices個int一級指針的內存空間
  gm->Edge = (int**)malloc(sizeof(int*) * (gm->MaxVertices));
  assert(NULL != gm->Edge);
  //開辟gm->MaxVertices組，能存放gm->MaxVertices個int的內存空間
  for(int i = 0; i < gm->MaxVertices; ++i){
    gm->Edge[i] = (int*)malloc(sizeof(int) * gm->MaxVertices);
  }
  //初始化二維數組
  //讓每個頂點之間的邊的關系都為不相連的
  for(int i = 0; i < gm->MaxVertices; ++i){
    for(int j = 0; j < gm->MaxVertices; ++j){
      if(i == j)
	gm->Edge[i][j] = 0;
      else
	gm->Edge[i][j] = MAX_COST;
    }
  }
}
//打印二維數組
void show_graph(GraphMtx* gm){
  printf("  ");
  for(int i = 0; i < gm->NumVertices; ++i){
    printf("%c  ", gm->VerticesList[i]);
  }
  printf("\n");
  for(int i = 0; i < gm->NumVertices; ++i){
    //在行首,打印出頂點的名字
    printf("%c:", gm->VerticesList[i]);
    for(int j = 0; j < gm->NumVertices; ++j){
      if(gm->Edge[i][j] == MAX_COST){
	printf("%c  ", '*');
      }
      else{
	printf("%d  ", gm->Edge[i][j]);
      }
    }
    printf("\n");
  }
  printf("\n");
}
//插入頂點
void insert_vertex(GraphMtx* gm, T v){
  //頂點空間已滿，不能再插入頂點了
  if(gm->NumVertices >= gm->MaxVertices){
    return;
  }
  gm->VerticesList[gm->NumVertices++] = v;
}

int getVertexIndex(GraphMtx* gm, T v){
  for(int i = 0; i < gm->NumVertices; ++i){
    if(gm->VerticesList[i] == v)return i;
  }
  return -1;
}
//添加頂點間的線
void insert_edge(GraphMtx* gm, T v1, T v2, E cost){
  if(v1 == v2)return;
  
  //查找2個頂點的下標
  int j = getVertexIndex(gm, v1);
  int k = getVertexIndex(gm, v2);
  //說明找到頂點了,並且點之間還沒有線
  if(j != -1 && k != -1 ){
    //因為是無方向，所以更新2個值
    gm->Edge[j][k] = gm->Edge[k][j] = cost;
    //邊數加一
    gm->NumEdges++;
  }
}
//刪除頂點間的線
void remove_edge(GraphMtx* gm, T v1, T v2){
  if(v1 == v2)return;
  //查找2個頂點的下標
  int j = getVertexIndex(gm, v1);
  int k = getVertexIndex(gm, v2);
  //說明找到頂點了,並且點之間還有線
  if(j != -1 && k != -1 && gm->Edge[j][k] == 1){
    //因為是無方向，所以更新2個值
    gm->Edge[j][k] = gm->Edge[k][j] = 0;
    //邊數減一
    gm->NumEdges--;
  }
}
//刪除頂點
void remove_vertex(GraphMtx* gm, T v){
  int k = getVertexIndex(gm, v);
  if(-1 == k)return;
  
  //算出和要刪除節點相關的邊的數量，並減少。
  for(int i = 0; i < gm->NumVertices; ++i){
    if(gm->Edge[k][i] == 1){
      gm->NumEdges--;
    }
  }

  //如果要刪除的頂點不是最后一個頂點
  if(k != gm->NumVertices - 1){
    //把每一列向左移動一列
    for(int i = 0; i < gm->NumVertices; ++i){
      //把后面內存里的內容移動到前面，並把最后一個元素設置成0
      memmove(&(gm->Edge[i][k]), &(gm->Edge[i][k+1]), sizeof(int) * (gm->NumVertices-1-k));
      gm->Edge[i][gm->NumVertices - 1] = 0;
    }
    //把每一行向上移動一行
    for(int i = k; i < gm->NumVertices - 1; ++i){
      memmove(gm->Edge[i], gm->Edge[i+1], sizeof(int) * (gm->NumVertices-1));
    }
    memset(gm->Edge[gm->NumVertices - 1], 0, sizeof(int) * (gm->NumVertices - 1));
    //memmove(&(gm->Edge[k]), &(gm->Edge[k+1]), sizeof(int*) * (gm->NumVertices-1-k));
    //memset(gm->Edge[gm->NumVertices - 1], 0, sizeof(int) * (gm->NumVertices - 1));

    //刪除點
    memmove(&(gm->VerticesList[k]), &(gm->VerticesList[k+1]), sizeof(T) * (gm->NumVertices-1-k));
  }
  //如果要刪除的頂點是最后一個頂點
  else{
    for(int i = 0; i < gm->NumVertices; ++i){
      gm->Edge[i][k] = gm->Edge[k][i] = 0;
    }
  }

  //節點數目減1
  gm->NumVertices--;
}

//摧毀圖
void destroy_graph(GraphMtx* gm){
  free(gm->VerticesList);
  for(int i = 0; i < gm->NumVertices; ++i){
    free(gm->Edge[i]);
  }
  free(gm->Edge);
  gm->Edge = NULL;
  gm->VerticesList = NULL;
  gm->MaxVertices = gm->NumVertices = gm->NumEdges = 0;
}

//取得與某頂點有連線的第一個頂點
int getNeighbor(GraphMtx* gm, T v){
  int p = getVertexIndex(gm, v);
  if(-1 == p)return -1;
  for(int i = 0; i < gm->NumVertices; ++i){
    if(gm->Edge[p][i] == 1)
      return i;
  }
  return -1;
}

//取得與v1頂點，v1頂點之后的v2頂點的之后的有連線的第一個頂點
int getNextNeighbor(GraphMtx* gm, T v1, T v2){
  if(v1 == v2)return -1;
  int p1 = getVertexIndex(gm, v1);
  int p2 = getVertexIndex(gm, v2);
  if(p1 == -1 || p2 == -1)return -1;

  for(int i = p2 + 1; i < gm->NumVertices; ++i){
    if(gm->Edge[p1][i] == 1)
      return i;
  }

  return -1;
}

//取得2個頂點間的權重
E getWeight(GraphMtx* g, int i1, int i2){
  if(i1 == -1 || i2 == -1)
    return MAX_COST;
  else
    return g->Edge[i1][i2];
}
//用prim算法作成最小樹
void minSpanTree_prim(GraphMtx* g, T v){
  int n = g->NumVertices;
  E* lowcost = (E*)malloc(sizeof(E) * n);
  int* mst = (int*)malloc(sizeof(int) * n);
  assert(lowcost != NULL && mst != NULL);

  int k = getVertexIndex(g, v);

  for(int i = 0; i < n; ++i){
    if(i != k){
      lowcost[i] = getWeight(g, k, i);
      mst[i] = k;
    }
    else{
      lowcost[i] = 0;
    }
  }

  int min, min_index;
  int begin, end;
  E cost;
  for(int i = 0; i < n - 1; ++i){
    min = MAX_COST;
    min_index = -1;
    for(int j = 0; j < n; ++j){
      if(lowcost[j] != 0 && lowcost[j] < min){
	min = lowcost[j];
	min_index = j;
      }
    }
    begin = mst[min_index];
    end = min_index;
    printf("%c->%c:%d\n",g->VerticesList[begin],g->VerticesList[end],min);

    lowcost[min_index] = 0;

    for(int j = 0; j < n; ++j){
      cost = getWeight(g, min_index, j);
      if(cost < lowcost[j]){
	lowcost[j] = cost;
	mst[j] = min_index;
      }
    }
  }

}

mixSpanTreemain.c

#include "mixSpanTree.h"

int main(){
  GraphMtx gm;
  //初始化圖
  init_graph(&gm);
  //插入頂點
  insert_vertex(&gm, 'A');
  insert_vertex(&gm, 'B');
  insert_vertex(&gm, 'C');
  insert_vertex(&gm, 'D');
  insert_vertex(&gm, 'E');
  insert_vertex(&gm, 'F');

  //添加連線
  insert_edge(&gm, 'A', 'B', 6);
  insert_edge(&gm, 'A', 'D', 5);
  insert_edge(&gm, 'A', 'C', 1);
  insert_edge(&gm, 'B', 'E', 3);
  insert_edge(&gm, 'B', 'C', 5);
  insert_edge(&gm, 'C', 'E', 6);
  insert_edge(&gm, 'C', 'D', 5);
  insert_edge(&gm, 'C', 'F', 4);
  insert_edge(&gm, 'F', 'E', 6);
  insert_edge(&gm, 'D', 'F', 2);
  //打印圖
  show_graph(&gm);

  //prim
  minSpanTree_prim(&gm, 'E');

  //摧毀圖
  destroy_graph(&gm);

}

完整代碼
編譯方法： gcc -g mixSpanTree.c mixSpanTreemain.c