/// <summary>
/// Constructeur
/// </summary>
/// <param name="NumberNodes"></param>
/// <param name="NumberEdges"></param>
public KruskalGraph(int NumberNodes, int NumberEdges)
{
NumberofNodes = NumberNodes;
NumberOfEdges = NumberEdges;
Edges = new KruskalEdge[NumberOfEdges];
for (int i = 0; i < NumberEdges; ++i)
{
Edges[i] = new KruskalEdge();
}
}
/// <summary>
/// Krukal 最小支撑树
/// <remarks>
/// 要求
/// <list type="Dot">
/// 无向图
/// </list>
/// <list type="Dot">
/// 单连通
/// </list>
/// </remarks>
/// </summary>
public void Kruskal()
{
Reset();
IPriorityQueue <KruskalEdge> edges = BuildEdgeHeap();
IVector <IVector <int> > vertexs = BuildVertex();
while (vertexs.Size != 1)
{
KruskalEdge edge = edges.DelMax();
int from = -1;
int to = -1;
for (int i = 0; i < vertexs.Size; i++)
{
if (vertexs[i].Find(edge.From) != -1)
{
from = i;
}
if (vertexs[i].Find(edge.To) != -1)
{
to = i;
}
}
if (from != to)
{
for (int i = 0; i < vertexs[to].Size; i++)
{
vertexs[from].Insert(vertexs[to][i]);
}
vertexs.Remove(to);
if (Exist(edge.From, edge.To))
{
Status(edge.From, edge.To, EStatus.Tree);
}
else
{
Status(edge.To, edge.From, EStatus.Tree);
}
}
}
}
public static KruskalEdge[] KruskalAlg(Graph graph)
{
int verticesCount = graph.VerticesCount;
Debug.Log("Vertices Count: " + verticesCount);
KruskalEdge[] result = new KruskalEdge[verticesCount];
int i = 0;
int e = 0;
Array.Sort(graph.edge, delegate(KruskalEdge a, KruskalEdge b)
{
return(a.Weight.CompareTo(b.Weight));
});
Subset[] subsets = new Subset[verticesCount];
for (int v = 0; v < verticesCount; ++v)
{
subsets[v].Parent = v;
subsets[v].Rank = 0;
}
while (e < verticesCount - 1)
{
Debug.Log("e : " + e + "i :" + i);
KruskalEdge nextEdge = graph.edge[i++];
int x = Find(subsets, nextEdge.Source);
int y = Find(subsets, nextEdge.Destination);
if (x != y)
{
result[e++] = nextEdge;
Union(subsets, x, y);
}
}
return(result);
}
/// <summary>
/// Kruskal algorythm
/// </summary>
public List<KruskalEdge> KruskalMST()
{
//Stocke le résultat de l'algorithme
List<KruskalEdge> result = new List<KruskalEdge>();
//Réorganise le tableau dans l'ordre de leur poids du plus petit au plus grand
Array.Sort(Edges);
// Allocate memory for creating V Nodes
KruskalNode[] subsets = new KruskalNode[NumberofNodes];
for (int i = 0; i < NumberofNodes; ++i)
{
subsets[i] = new KruskalNode();
subsets[i].Parent = i;
subsets[i].Value = 0;
}
int j = 0; // Index used to pick next edge
int e = 0; // An index variable, used for result[]
// Number of edges to be taken is equal to V-1
while (e < NumberofNodes - 1)
{
// Step 2: Pick the smallest edge. And increment the index
// for next iteration
KruskalEdge next_edge = new KruskalEdge();
next_edge = Edges[j++];
int x = Find(subsets, next_edge.From);
int y = Find(subsets, next_edge.To);
// If including this edge does't cause cycle, include it
// in result and increment the index of result for next edge
if (x != y)
{
result.Add(new KruskalEdge());
result[e++] = next_edge;
Union(subsets, x, y);
}
// Else discard the next_edge
}
return result;
}
