邻接表创建无向图（C++、广度优先遍历、路径寻找）

1、数据结构定义

typedef enum {BAD=0,OK=1} Status;

//邻接表--无向图
#define MaxNum 100        //最大顶点数
typedef struct bian_node//边结点
{
    int dingdian_pos;//该边连接的另一个顶点的位置（下标：0~MaxNum-1）
    struct bian_node *next;//和该边连在同一个顶点的另外一条边
}bian_node;

typedef struct dingdian_node//顶点结点
{
    char info;                //顶点信息
    bian_node *first_bian;    //连接该顶点的第一条边（随便哪一条边都可以是第一条边）
}dingdian_node;

 

2、类定义

class Graph
{
    public:
    bool visited[MaxNum];//访问标志数组：对应顶点被访问后置为true
    dingdian_node dingdian_list[MaxNum];//顶点数组(0~MaxNum)
    int bian_num,dingdian_num;//边、顶点数量

    //邻接表创建无向图
    Status CreateUDG();
    //验证
    void CheckUDG();
    //广度优先遍历(从顶点v开始)
    void BFS(int v);
    //功能实现:找到最小连通图中 abb 样式的路径，输出序号(要保证输入的图是一个最小连通图，否则无效)
    void find_paths();
};

3、类基本功能实现（创建图、验证是否创建成功）

Status Graph::CreateUDG()
{
    memset(this->visited,0,sizeof(visited));//标志数组初始化为false
    cin>>this->dingdian_num>>this->bian_num;//输入总顶点数，总边数
    for(int i=0;i<this->dingdian_num;i++)
    {
        cin>>this->dingdian_list[i].info;       //输入各顶点值
        this->dingdian_list[i].first_bian=NULL; //初始化表头结点指针域为NULL
    }
    //cout<<"bian_num:"<<this->bian_num<<endl;
    for(int i=0;i<this->bian_num;i++)
    {
        int v1,v2;//一条边依附的两个顶点在dingdian_list中的序号
        cin>>v1>>v2;//输入边
        //cout<<"v1:"<<v1<<" v2:"<<v2<<endl;
        //头插法插入边结点
        bian_node *p=new bian_node;
        p->dingdian_pos=v2;
        p->next=this->dingdian_list[v1].first_bian;
        this->dingdian_list[v1].first_bian=p;
        //无向图的边是对称的，另一个对应结点也要插入这条边
        bian_node *p2=new bian_node;
        p2->dingdian_pos=v1;
        p2->next=this->dingdian_list[v2].first_bian;
        this->dingdian_list[v2].first_bian=p2;
    }
    return OK;
}

void Graph::CheckUDG()
{
    for(int i=0;i<this->dingdian_num;i++)
    {
        bian_node *temp;
        temp=this->dingdian_list[i].first_bian;
        cout<<this->dingdian_list[i].info<<":";
        while(temp)
        {
            //输出每一个顶点连接的另一个顶点的下标
            cout<<temp->dingdian_pos<<" ";
            temp=temp->next;
        }
        cout<<endl;
    }
}

运行效果：

4、广度优先遍历、路径寻找

void Graph::BFS(int v)
{
    queue<int> q;
    cout<<v<<" ";
    this->visited[v]=true;
    //广度优先遍历就和树的层次遍历一样，要用到队列结构
    q.push(v);
    while(!q.empty())
    {
        int i;
        int t=q.front();
        q.pop();
        bian_node *tmp=this->dingdian_list[t].first_bian;
        while(1)
        {
            if(tmp==NULL)
                break;
            i=tmp->dingdian_pos;
            if(this->visited[i]==false)
            {
                cout<<i<<" ";
                this->visited[i]=true;
                q.push(i);
            }
            tmp=tmp->next;
        }
    }
}

void Graph::find_paths()
{
    vector<vector<char>> vv;
    vector<vector<int>> vv2;
    //遍历每一个顶点，查找是否有对应路径
    for(int i=0;i<this->dingdian_num;i++)
    {
        char t1,t2,t3;//存放顶点的值
        int r1,r2,r3;//存放查找到的路径的顶点的下标
        bian_node *tmp;
        r1=i;
        t1=this->dingdian_list[i].info;
        tmp=this->dingdian_list[i].first_bian;
        while(tmp)
        {
            int pos=tmp->dingdian_pos;
            char t=this->dingdian_list[pos].info;
            if(t!=t1)
            {
                r2=pos;
                t2=t;
                bian_node *tmp_2;
                tmp_2=this ->dingdian_list[pos].first_bian;
                while(tmp_2)
                {
                    int pos_2=tmp_2->dingdian_pos;
                    char tt=this->dingdian_list[pos_2].info;
                    //cout<<"i:"<<i<<" t1:"<<t1<<" t2:"<<t2<<" pos_2:"<<pos_2<<" tt:"<<tt<<endl;
                    if(tt==t2)
                    {
                        //cout<<"i:"<<i<<" t1:"<<t1<<" t2:"<<t2<<" tt:"<<tt<<endl;
                        r3=pos_2;
                        t3=t2;
                        cout<<"t1:"<<t1<<" t2:"<<t2<<" t3:"<<t3<<endl;
                        vector<char> tmp_v;
                        tmp_v.push_back(t1);
                        tmp_v.push_back(t2);
                        tmp_v.push_back(t3);
                        vv.push_back(tmp_v);

                        vector<int> tmp_v2;
                        tmp_v2.push_back(r1);
                        tmp_v2.push_back(r2);
                        tmp_v2.push_back(r3);
                        vv2.push_back(tmp_v2);
                    }
                    tmp_2=tmp_2->next;
                }
            }
            tmp=tmp->next;
        }
    }

    //依次输出
    if(vv.size()<=0)
    {
        cout<<"NULL\n";
        return;
    }
    for(int i=0;i<vv.size();i++)
    {
        for(int j=0;j<vv[i].size();j++)
        {
            cout<<vv2[i][j]<<"--";
            cout<<vv[i][j]<<" ";
        }
        cout<<endl;
    }
}

 

5、主函数

int main()
{
    //cout<<sizeof(bool)<<endl;
    Graph G;
    if(G.CreateUDG()==OK)
        G.CheckUDG();
    //G.BFS(0);
    G.find_paths();
    return 0;
}