数据结构之最小生成树Kruskal算法

时间：2022-05-13 11:39:50

1. 克鲁斯卡算法介绍

　　克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。

　　基本思想：按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。
　　具体做法：首先构造一个只含n个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止。

2. 克鲁斯卡算法图解

数据结构之最小生成树Kruskal算法

第1步：将边<E,F>加入R中。     

　　边<E,F>的权值最小，因此将它加入到最小生成树结果R中。

第2步：将边<C,D>加入R中。     

　　上一步操作之后，边<C,D>的权值最小，因此将它加入到最小生成树结果R中。

第3步：将边<D,E>加入R中。     

　　上一步操作之后，边<D,E>的权值最小，因此将它加入到最小生成树结果R中。

第4步：将边<B,F>加入R中。     

　　上一步操作之后，边<C,E>的权值最小，但<C,E>会和已有的边构成回路；因此，跳过边<C,E>。同理，跳过边<C,F>。将边<B,F>加入到最小生成树结果R中。

第5步：将边<E,G>加入R中。     

　　上一步操作之后，边<E,G>的权值最小，因此将它加入到最小生成树结果R中。

第6步：将边<A,B>加入R中。     

　　上一步操作之后，边<F,G>的权值最小，但<F,G>会和已有的边构成回路；因此，跳过边<F,G>。同理，跳过边<B,C>。将边<A,B>加入到最小生成树结果R中。

此时，最小生成树构造完成！它包括的边依次是：<E,F> <C,D> <D,E> <B,F> <E,G> <A,B>。

3. 代码实现

（1）根据图链表顶点信息得到所有边信息

EData* listUDG::GetEdage()
{
    EData *pEdata = new EData[m_nEdgNum];
    ENode *pTemp = NULL;
    int nEdgNum = 0;
    for (int i = 0; i < m_nVexNum; i ++)
    {
        pTemp = m_mVexs[i].pFirstEdge;
        while(pTemp != NULL)
        {
            if (pTemp->nVindex > i) // 可以不需要改代码，但是为了严谨和效率
            {
                pEdata[nEdgNum].nStart = m_mVexs[i].data;
                pEdata[nEdgNum].nEnd = m_mVexs[pTemp->nVindex].data;
                pEdata[nEdgNum].nWeight = pTemp->nWeight;

                nEdgNum ++;
            }
            pTemp = pTemp->pNext;
        }
    }

    return pEdata;
}

（2）对所有边根据权重值大小进行排序

void listUDG::SortEdges(EData* edges, int elen) 
{ 
    int i,j; 
    for (i=0; i<elen; i++) 
    { 
        for (j=i+1; j<elen; j++) 
        { 
            if (edges[i].nWeight > edges[j].nWeight) 
            { 
                // 交换"边i"和"边j" 
                swap(edges[i], edges[j]); 
            } 
        } 
    } 
}

（3）判断选取的边是否构成回路

　　若0->1->2->3->4 　　5->3

　　则a[0]=1;a[1]=2;a[2]=3;a[3]=4;

　　　a[5]=3;

　　因为a[5]和a[2]的尾顶点都是3，则构成回路

int listUDG::GetEnd(int *vends, int i)
{
    while(vends[i] != 0)
    {
        i = vends[i];
    }

    return i;
}

（4）Kruskal算法

// kruska最小生成树
void listUDG::Kruskal()
{
    // 得到所有的边
    EData *pEdata = GetEdage();
    // 根据边的权重进行排序
    SortEdges(pEdata,m_nEdgNum);
    int vends[MAX] = {0};     // 用于保存"已有最小生成树"中每个顶点在该最小树中的终点。
    EData rets[MAX];      // 结果数组，保存kruskal最小生成树的边  
    int nStartIndex,nEndIndex;
    int nIndex = 0;
    int m,n;
    for (int i = 0; i < m_nEdgNum; i ++)
    {
        nStartIndex = GetVIndex(pEdata[i].nStart);
        nEndIndex = GetVIndex(pEdata[i].nEnd);

        m = GetEnd(vends, nStartIndex);
        n = GetEnd(vends, nEndIndex);
        if (m != n)
        {
            vends[m] = n;                // 设置m在"已有的最小生成树"中的终点为n
            rets[nIndex++] = pEdata[i];           // 保存结果
        }
    }

    delete[] pEdata;

    int nSum = 0; 
    for (int i = 0; i < nIndex; i++) 
        nSum += rets[i].nWeight; 
    cout << "Kruskal=" << nSum << ": "; 
    for (int i = 0; i < nIndex; i++) 
        cout << "(" << rets[i].nStart << "," << rets[i].nEnd << ") "; 
    cout << endl; 
}

（5）全部代码

数据结构之最小生成树Kruskal算法数据结构之最小生成树Kruskal算法
#include "stdio.h"
#include <iostream>
using namespace std;

#define MAX 100
#define INF         (~(0x1<<31))        // 最大值(即0X7FFFFFFF)

class EData
{
public:
    EData(){}
    EData(char start, char end, int weight) : nStart(start), nEnd(end), nWeight(weight){}
    
    char nStart;
    char nEnd;
    int nWeight;
};
// 边
struct ENode
{
    int nVindex;  // 该边所指的顶点的位置
    int nWeight;  // 边的权重
    ENode *pNext; // 指向下一个边的指针
};

struct VNode
{
    char data;  // 顶点信息
    ENode *pFirstEdge; // 指向第一条依附该顶点的边
};

// 无向邻接表
class listUDG
{
public:
    listUDG();
    listUDG(char *vexs, int vlen, EData **pEData, int elen);
    ~listUDG();

    void PrintUDG();
    // Prim最小生成树
    void Prim(int nStart);
    // 得到所有的边
    EData* GetEdage();
    // kruska最小生成树
    void Kruskal();
private:
    // 获取<start, end>的权值，若start和end不是连接的，则返回无穷大
    int GetWeight(int start, int end);
    // 返回顶点的索引
    int GetVIndex(char ch);
    void LinkLast(ENode *pFirstNode, ENode *pNode);
    void QuickSort(EData* pEdata, int nEdgNum);
    void SortEdges(EData* edges, int elen);
    int GetEnd(int *vends, int i);
private:
    int m_nVexNum;   // 顶点数目
    int m_nEdgNum;   // 边数目
    VNode m_mVexs[MAX];
    VNode m_PrimVexs[MAX];
};

listUDG::listUDG()
{

}
listUDG::listUDG(char *vexs, int vlen, EData **pEData, int elen)
{
    m_nVexNum = vlen;
    m_nEdgNum = elen;

    // 初始化"邻接表"的顶点
    for (int i = 0; i < vlen; i ++)
    {
        m_mVexs[i].data = vexs[i];
        m_mVexs[i].pFirstEdge = NULL;
    }

    char c1,c2;
    int p1,p2;
    ENode *node1, *node2;
    // 初始化"邻接表"的边
    for (int j = 0; j < elen; j ++)
    {
        // 读取边的起始顶点和结束顶点
        c1 = pEData[j]->nStart;
        c2 = pEData[j]->nEnd;
        p1 = GetVIndex(c1);
        p2 = GetVIndex(c2);

        node1 = new ENode();
        node1->nVindex = p2;
        node1->nWeight = pEData[j]->nWeight;
        if (m_mVexs[p1].pFirstEdge == NULL)
        {
            m_mVexs[p1].pFirstEdge = node1;
        }
        else
        {
            LinkLast(m_mVexs[p1].pFirstEdge, node1);
        }

        node2 = new ENode();
        node2->nVindex = p1;
        node2->nWeight = pEData[j]->nWeight;
        if (m_mVexs[p2].pFirstEdge == NULL)
        {
            m_mVexs[p2].pFirstEdge = node2;
        }
        else
        {
            LinkLast(m_mVexs[p2].pFirstEdge, node2);
        }
    }

}
listUDG::~listUDG()
{
    ENode *pENode = NULL;
    ENode *pTemp = NULL;
    for (int i = 0; i < m_nVexNum; i ++)
    {
        pENode = m_mVexs[i].pFirstEdge;
        if (pENode != NULL)
        {
            pTemp = pENode;
            pENode = pENode->pNext;

            delete pTemp;
        }
        delete pENode;
    }
}

void listUDG::PrintUDG()
{ 
    ENode *pTempNode = NULL;
    cout << "邻接无向表:" << endl;
    for (int i = 0; i < m_nVexNum; i ++)
    {
        cout << "顶点:" << GetVIndex(m_mVexs[i].data)<< "-" << m_mVexs[i].data<< "->";
        pTempNode = m_mVexs[i].pFirstEdge;
        while (pTempNode)
        {
            cout <<pTempNode->nVindex << "->";
            pTempNode = pTempNode->pNext;
        }
        cout << endl;
    }
}

// Prim最小生成树
void listUDG::Prim(int nStart)
{
    int i = 0;
    int nIndex=0;         // prim最小树的索引，即prims数组的索引 
    char cPrims[MAX];     // prim最小树的结果数组 
    int weights[MAX];    // 顶点间边的权值

    cPrims[nIndex++] = m_mVexs[nStart].data;

    // 初始化"顶点的权值数组"，
    // 将每个顶点的权值初始化为"第start个顶点"到"该顶点"的权值。
    for (i = 0; i < m_nVexNum; i++)
    {
        weights[i] = GetWeight(nStart, i);
    }

    for (i = 0; i < m_nVexNum; i ++)
    {
        if (nStart == i)
        {
            continue;
        }

        int min = INF;
        int nMinWeightIndex = 0;
        for (int k = 0; k < m_nVexNum; k ++)
        {
            if (weights[k]!= 0 && weights[k] < min)
            {
                min = weights[k];
                nMinWeightIndex = k;
            }
        }

        // 找到下一个最小权重值索引
        cPrims[nIndex++] = m_mVexs[nMinWeightIndex].data;
        // 以找到的顶点更新其他点到该点的权重值
        weights[nMinWeightIndex]=0;
        int nNewWeight = 0;
        for (int ii = 0; ii < m_nVexNum; ii++)
        {
            nNewWeight = GetWeight(nMinWeightIndex, ii);
            // 该位置需要特别注意
            if (0 != weights[ii] && weights[ii] > nNewWeight)
            {
                weights[ii] = nNewWeight;
            }
        }
    }
    // 计算最小生成树的权重值
    int nSum = 0;
    for (i = 1; i < nIndex; i ++)
    {
        int min = INF;
        int nVexsIndex = GetVIndex(cPrims[i]);
        for (int kk = 0; kk < i; kk ++)
        {
            int nNextVexsIndex = GetVIndex(cPrims[kk]);
            int nWeight = GetWeight(nVexsIndex, nNextVexsIndex);
            if (nWeight < min)
            {
                min = nWeight;
            }
        }
        nSum += min;
    }

    // 打印最小生成树 
    cout << "PRIM(" << m_mVexs[nStart].data  <<")=" << nSum << ": "; 
    for (i = 0; i < nIndex; i++) 
        cout << cPrims[i] << " "; 
    cout << endl; 
}

// 得到所有的边
EData* listUDG::GetEdage()
{
    EData *pEdata = new EData[m_nEdgNum];
    ENode *pTemp = NULL;
    int nEdgNum = 0;
    for (int i = 0; i < m_nVexNum; i ++)
    {
        pTemp = m_mVexs[i].pFirstEdge;
        while(pTemp != NULL)
        {
            if (pTemp->nVindex > i) // 可以不需要改代码，但是为了严谨和效率
            {
                pEdata[nEdgNum].nStart = m_mVexs[i].data;
                pEdata[nEdgNum].nEnd = m_mVexs[pTemp->nVindex].data;
                pEdata[nEdgNum].nWeight = pTemp->nWeight;

                nEdgNum ++;
            }
            pTemp = pTemp->pNext;
        }
    }

    return pEdata;
}
// 根据权重值对所有的边进行排序
void listUDG::SortEdges(EData* edges, int elen) 
{ 
    int i,j; 
    for (i=0; i<elen; i++) 
    { 
        for (j=i+1; j<elen; j++) 
        { 
            if (edges[i].nWeight > edges[j].nWeight) 
            { 
                // 交换"边i"和"边j" 
                swap(edges[i], edges[j]); 
            } 
        } 
    } 
} 

int listUDG::GetEnd(int *vends, int i)
{
    while(vends[i] != 0)
    {
        i = vends[i];
    }

    return i;
}
// kruska最小生成树
void listUDG::Kruskal()
{
    // 得到所有的边
    EData *pEdata = GetEdage();
    // 根据边的权重进行排序
    SortEdges(pEdata,m_nEdgNum);
    int vends[MAX] = {0};     // 用于保存"已有最小生成树"中每个顶点在该最小树中的终点。
    EData rets[MAX];      // 结果数组，保存kruskal最小生成树的边  
    int nStartIndex,nEndIndex;
    int nIndex = 0;
    int m,n;
    for (int i = 0; i < m_nEdgNum; i ++)
    {
        nStartIndex = GetVIndex(pEdata[i].nStart);
        nEndIndex = GetVIndex(pEdata[i].nEnd);

        m = GetEnd(vends, nStartIndex);
        n = GetEnd(vends, nEndIndex);
        if (m != n)
        {
            vends[m] = n;                // 设置m在"已有的最小生成树"中的终点为n
            rets[nIndex++] = pEdata[i];           // 保存结果
        }
    }

    delete[] pEdata;

    int nSum = 0; 
    for (int i = 0; i < nIndex; i++) 
        nSum += rets[i].nWeight; 
    cout << "Kruskal=" << nSum << ": "; 
    for (int i = 0; i < nIndex; i++) 
        cout << "(" << rets[i].nStart << "," << rets[i].nEnd << ") "; 
    cout << endl; 
}
// 获取<start, end>的权值，若start和end不是连接的，则返回无穷大
int listUDG::GetWeight(int start, int end)
{
    if (start == end)
    {
        return 0;
    }
    ENode *pTempNode = m_mVexs[start].pFirstEdge;
    while (pTempNode)
    {
        if (end == pTempNode->nVindex)
        {
            return pTempNode->nWeight;
        }
        pTempNode = pTempNode->pNext;
    }

    return INF;
}

// 返回顶点的索引
int listUDG::GetVIndex(char ch)
{
    int i = 0;
    for (; i < m_nVexNum; i ++)
    {
        if (m_mVexs[i].data == ch)
        {
            return i;
        }
    }
    return -1;
}

void listUDG::LinkLast(ENode *pFirstNode, ENode *pNode)
{
    if (pFirstNode == NULL || pNode == NULL)
    {
        return;
    }
    ENode *pTempNode = pFirstNode;
    while (pTempNode->pNext != NULL)
    {
        pTempNode = pTempNode->pNext;
    }

    pTempNode->pNext = pNode;
}


void main()
{
    char vexs[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'}; 
    // 边 
    EData *edges[] = { 
               // 起点 终点 权 
        new EData('A', 'B', 12),  
        new EData('A', 'F', 16),  
        new EData('A', 'G', 14),  
        new EData('B', 'C', 10),  
        new EData('B', 'F',  7),  
        new EData('C', 'D',  3),  
        new EData('C', 'E',  5),  
        new EData('C', 'F',  6),  
        new EData('D', 'E',  4),  
        new EData('E', 'F',  2),  
        new EData('E', 'G',  8),  
        new EData('F', 'G',  9)
    };
    int vlen = sizeof(vexs)/sizeof(vexs[0]); 
    int elen = sizeof(edges)/sizeof(edges[0]); 
    listUDG* pG = new listUDG(vexs, vlen, edges, elen); 

    pG->PrintUDG();   // 打印图 
    pG->Prim(0);
    pG->Kruskal();
    for (int i = 0; i < elen; i ++)
    {
        delete edges[i];
    }
    return; 
}
View Code

数据结构之最小生成树Kruskal算法

注：感谢 skywang12345博主提供的内容分析，要了解更多详细信息可参考原博 http://www.cnblogs.com/skywang12345/p/3711500.html
标签：

相关文章