无向图的最小支撑树Kruskal算法的实现

关注

原创最新推荐文章于 2026-08-05 12:45:31 发布 1.4k 阅读 AI 写同款· GEO 优化 ›

最小支撑树MST 如果X本身是稀疏的，sparse(X)返回S。用法2：S = sparse(i,j,s,m,n,nzmax)——由i,j,s三个向量创建一个m*n的稀疏矩阵（上面的B矩阵形式），并且最多含有nzmax个元素。3）S = sparse(m,n)——sparse([],[],[],m,n,0)的缩写，生成一个m*n的所有元素都是0的稀疏矩阵。实验习题：已知六大城市：(Pe)，(N)，(Pa)，(L)，(T)，(M)，它们之间的交通网络数据如下表所示，求最小支撑树。3)对于有圈的,将这条边删除,否则,往下查找；阅读详情

// 无向图的最小支撑树Kruskal算法的实现
//主题：用邻接表的方式实现最小支撑树Kruskal算法

//作者：Andyhou

//时间：2008年4月28日

//具体算法实现：
// 采用的是最小堆的方式找最小边，用等价类的方式步步合并最小的边。
// 程序中还声明了一个等价类。
#include <iostream>
using namespace std;

const int MaxNode=100;
const int VISITED=1;
const int UNVISITED=0;
const int ROOT=-1;
const int INFINITY=9999;

struct Node
{
int adjvex;           //终点顶点
int weight;           //权
struct Node *next;    //指向下个顶点的指针
};
class VNode
{
public:
int data;
struct Node* first;    //指向第一个邻接顶点
VNode(){}
VNode(int Data,struct Node* firstVal)
{
  data=Data;
  first=firstVal;
}
VNode(struct Node* firstVal)
{
  first=firstVal;
}

};
//用于最小支撑树的边类
class Edge
{
public:
int from,to,weight;
Edge()
{
  from=-1;
  to=-1;
  weight=0;
}
Edge(int f,int t,int w)
{
  from=f;
  to=t;
  weight=w;
}
bool operator>(Edge oneEdge)
{
  return weight>oneEdge.weight;
}
bool operator<(Edge oneEdge)
{
  return weight<oneEdge.weight;
}
bool operator==(Edge oneEdge)
{
  return weight==oneEdge.weight;
}
};

//用于”父指针"发表示等价类的类
class Gentree
{
private:
int *Array;
int size;
public:
Gentree(int sz)
{
  size=sz;
  Array=new int[sz+1];
  for(int i=1;i<=sz;i++)
   Array[i]=ROOT;       //整个数的根节点
}
~Gentree()
{
  delete[] Array;
}
int FIND(int curr)       //寻找根的函数
{
  while(Array[curr]!=ROOT)
   curr=Array[curr];
  return curr;
}
void UNION(int a,int b) //将a和b合并到一个等价类中，a和b在一个等价类中就他们相同的根。
{
  int root1=FIND(a);
  int root2=FIND(b);
  if(root1!=root2)
   Array[root2]=root1;
}
bool differ(int a,int b) //判断a和b是否等价。
{
  int root1=FIND(a);
  int root2=FIND(b);
  return root1!=root2;
}
};

//最小值堆的建立
template <class T>
class MinHeap
{
private:
T* heapArray;
int CurrentSize;
int MaxSize;

public:
MinHeap(const int n);
virtual ~MinHeap()
{delete []heapArray;};
void BuildHeap();
bool isLeaf(int pos) const;
int leftchild(int pos) const;
int rightchild(int pos) const;
// Return parent position
int parent(int pos) const;
// 删除给定下标的元素
bool Remove(int pos, T& node);
void SiftDown(int left);
//从position向上开始调整，使序列成为堆
void SiftUp(int position);
bool Insert(const T& newNode);
T& RemoveMin();
bool empty()
{
  if(CurrentSize>0)
   return false;
  else
   return true;
}
};

template<class T>
MinHeap<T>::MinHeap(const int n)
{
if(n<=0)
return;
CurrentSize=0;
MaxSize=n;
heapArray=new T[MaxSize];
BuildHeap();
}

template<class T>
void MinHeap<T>::BuildHeap()
{
for (int i=CurrentSize/2-1; i>=0; i--)
SiftDown(i);
}

template<class T>
bool MinHeap<T>::isLeaf(int pos) const
{
return (pos>=CurrentSize/2)&&(pos<CurrentSize);
}

template<class T>
int MinHeap<T>::leftchild(int pos) const
{
return 2*pos+1; //返回左孩子位置
}

template<class T>
int MinHeap<T>::rightchild(int pos) const
{
return 2*pos+2; //返回右孩子位置
}

template<class T>
int MinHeap<T>::parent(int pos) const // 返回父节点位置
{
return (pos-1)/2;
}

template<class T>
void MinHeap<T>::SiftDown(int left)
{
//准备
int i=left;       //标识父结点
int j=2*i+1;      //标识关键值较小的子结点
T temp=heapArray[i];    //保存父结点
//过筛
while(j<CurrentSize)
{
  if((j<CurrentSize-1)&&(heapArray[j]>heapArray[j+1]))
   j++;      //j指向右子结点
  if(temp>heapArray[j])
  {
   heapArray[i]=heapArray[j];
   i=j;
   j=2*j+1;
  }
  else break;
}
heapArray[i]=temp;
}

template<class T>
void MinHeap<T>::SiftUp(int position)
{//从position向上开始调整，使序列成为堆
int temppos=position;
T temp=heapArray[temppos];
while((temppos>0)&&(heapArray[parent(temppos)]>temp))
{
heapArray[temppos]=heapArray[parent(temppos)];
temppos=parent(temppos);
}
heapArray[temppos]=temp;
}

template<class T>
bool MinHeap<T>::Insert(const T& newNode)
{//向堆中插入一个结点
if(CurrentSize==MaxSize)
return false;
heapArray[CurrentSize]=newNode;
SiftUp(CurrentSize);
CurrentSize++;
return true;
}

template<class T>
T& MinHeap<T>::RemoveMin()
{
if(CurrentSize==0)
{
cout<<"Can't Delete";

}
else
{
  T temp=heapArray[0];     //取堆顶元素
  heapArray[0]=heapArray[CurrentSize-1]; //堆末元素上升至堆顶
  CurrentSize--;
  if(CurrentSize>1)
   SiftDown(0);      //从堆顶开始筛选
  return temp;
}
}

template<class T>
bool MinHeap<T>::Remove(int pos, T& node)
{// 删除给定下标的元素
if((pos<0)||(pos>=CurrentSize))
  return false;
T temp=heapArray[pos];
heapArray[pos]=heapArray[--CurrentSize]; //指定元素置于最后
SiftUp(pos);        //上升筛
SiftDown(pos);        //向下筛
node=temp;
return true;
}

class ADJ
{
private:
int e;                             //边数
VNode *AdjList;                    //邻接表
int NNode;                         //顶点数
int MARK[MaxNode];                //访问标记数组
public:
ADJ(int itE,int itMaxNode)
{
  e=itE;
  NNode=itMaxNode;
  AdjList=new VNode[NNode+1];
  for(int i=0;i<NNode;i++)
  {
   AdjList[i].data=0;
   AdjList[i].first=NULL;
  }
}
~ADJ()
{
  delete[] AdjList;
}
void CreateAdj()
{
  int i,j;
        int item;
  struct Node* S;
  for(int a=1;a<=NNode;a++)
  {
   cout<<"输入第"<<a<<"个顶点数据";
   cin>>AdjList[a].data;
   AdjList[a].first=NULL;
  }
  for(int k=0;k<e;k++)
  {
   cout<<"输入边<Vi,Vj>的顶点对序列号：";
   cin>>i;
   cin>>j;
   cout<<"输入边的权：";
   cin>>item;
            S=new struct Node();
   S->adjvex=j;
   S->weight=item;
   S->next=AdjList[i].first;
   AdjList[i].first=S;          //连接两个顶点
   S=new struct Node();
   S->adjvex=i;
   S->weight=item;
   S->next=AdjList[j].first;
   AdjList[j].first=S;
  }
}

void printAll()
{
  cout<<"打印所有顶点的连接情况;"<<endl;
  for(int i=1;i<=NNode;i++)
  {
   struct Node* temp=AdjList[i].first;
   cout<<i;
   cout<<"("<<AdjList[i].data<<")";
   if(temp!=NULL)
    cout<<"---"<<temp->weight<<"-->";
   while(temp!=NULL)
   {
    cout<<temp->adjvex;
    cout<<"("<<AdjList[temp->adjvex].data<<")"<<"--"<<temp->weight<<"-->";
    temp=temp->next;
   }
   cout<<"---->NULL";
   cout<<endl;
  }
  cout<<"输出了所有数据！"<<endl;
}
void AddEdgetoMST(Edge &E,Edge *MST,int tag)
{
  MST[tag].from=E.from;
  MST[tag].to=E.to;
  MST[tag].weight=E.weight;
}
void Krushal();

};
void ADJ::Krushal()
{
Gentree A(NNode);               //等价类
MinHeap<Edge> H(e);             //最小值堆
struct Node *temp;
Edge * MST=new Edge[NNode-1];   //最小支撑树
int MSTtag=1;                   //最小支撑树的边的标记
Edge Ne;
for(int i=1;i<=NNode;i++)        //将图的所有边插入最小值堆H中
{
  temp=AdjList[i].first;
  while(temp!=NULL)
  {
   if(i<temp->adjvex)      //因为是无向图，所有应防止重复插入
   {
    Ne.from=i;
    Ne.to=temp->adjvex;
    Ne.weight=temp->weight;
    H.Insert(Ne);
   }
   temp=temp->next;
  }
}
int EquNum=NNode;     //开始有|V|个等价类
while(EquNum>1)          //合并等价类
{
   Ne=H.RemoveMin();    //获得下一条权最小的边
   if(Ne.weight==INFINITY)
   {
    cout<<"不存在最小支撑树:";
    delete[] MST;
    MST=NULL;
    return ;
   }
   int from=Ne.from;           //纪录该条边的信息
   int to=Ne.to;
   if(A.differ(from,to))       //如果边Ne的两个顶点不在一个等价类
   {
    A.UNION(from,to);        //将边Ne的连个顶点在的两个等价类合并为一个
    AddEdgetoMST(Ne,MST,MSTtag++); //将边e加到MST
    EquNum--;                       //将等价类的个数减1
   }
}
cout<<"输出无向图的最小支撑树的边和权：";
for(int i=1;i<NNode;i++)
  cout<<MST[i].from<<"--"<<MST[i].to<<"("<<MST[i].weight<<")/t";
cout<<endl;
}

int main()
{
int E,MaxNode;
cout<<"输入无向图的顶点数和边数：:";
cin>>MaxNode>>E;
ADJ T(E,MaxNode);
T.CreateAdj();
T.printAll();
cout<<endl;
cout<<"Kruskal算法的执行："<<endl;
T.Krushal();
return 0;
}

注：本程序在VC2005中编译成功的。

收录于