广度优先查找+深度优先查找

原理见图

//深度查找+广度查找

#include <iostream>
using namespace std;
#define max_v 50

//标志数组——判断是否被访问
int visit_d[50] = { 0 };//深度
int visit_b[50] = { 0 };//广度

//不包含顶点的横向链表,边为节点的边链表
struct e
{
    int e_v;//每条边的终点
    e* e_next;
};

//形成包含顶点的，边链表
struct v
{
    char v_info;//顶点以字母命名
    e* v_next;//顶点下一点是边终点
};

//纵向链表，以每条边链表，首节点组成的链表
//图包含，总顶点数总边数
struct g
{
    int v_num;
    int e_num;
    v r[max_v];
};

//建立邻接表,头插法
void create_G(g *G)
{
    g* G1 = G;
    e *e1, *e2;
    int i, j;
    cout << "输入顶点数和边数：    " << endl;
    cin >> G->v_num >> G->e_num;
    cout << "输入顶点表：    " << endl;
    for (int i = 0; i < G->v_num; i++)
    {
        cin >> G->r[i].v_info;
        G->r[i].v_next = NULL;
    }
    cout << "输入边表：    " << endl;
    for (int k = 0; k < G->e_num; k++)
    {
        //无向图
        cout << "输入边对应的顶点<Vi,Vj>:    ";
        cin >> i >> j;
        e1 = new e;
        e1->e_v = j;
        e1->e_next = G->r[i].v_next;
        G->r[i].v_next = e1;

        e2 = new e;
        e2->e_v = i;
        e2->e_next = G->r[j].v_next;
        G->r[j].v_next = e2;
    }
}

//深度优先查找——沿着顶点朝着一个方向延伸下去——直到都被访问

void DFS(g* G, char ch)
{
    e *p;//指向下一节点，用于链表移动
    for (int i = 0; i < G->v_num; i++)
    {
        if ((G->r[i].v_info == ch) && (visit_d[i] == 0))
        {
            cout << ch << " ";
            visit_d[i] = 1;//已访问 
            //如果，下一节点已经被访问，p后移，判断其他邻接点是否被访问
            p = G->r[i].v_next;
            while (p != NULL)
            {
                if (visit_d[p->e_v] == 0)
                {
                    DFS(G, G->r[p->e_v].v_info);
                    break;
                }
                p = p->e_next;

            }
        }
    }
}
//广度优先查找
void BFS(g* G, char ch)
{
    e *p;
    int queue[max_v];
    int front = 0;
    int rear = 0;
    int h;
    for (int i = 0; i < G->v_num; i++)
    {
        if (G->r[i].v_info == ch)
        {
            cout << ch << " ";
            visit_b[i] = 1;
            rear = (rear + 1) % max_v;//循环队列
            queue[rear] = i;//进队
            while (front != rear)
            {
                front = (front + 1) % max_v;
                h = queue[front];//出队列
                p = G->r[h].v_next;//找到顶点的第一个邻接点
                while (p != NULL)
                {
                    if (visit_b[p->e_v] == 0)
                    {
                        cout << G->r[p->e_v].v_info << " ";
                        visit_b[p->e_v] = 1;
                        rear = (rear + 1) % max_v;
                        queue[rear] = p->e_v;//该顶点进队列
                    }
                    p = p->e_next;
                }
            }
        }
    }
}

int main()
{
    g* G = new g;
    create_G(G);
    char ch;
    cout << "输入开始遍历的顶点\t";
    cin >> ch;
    cout << "深度遍历结果：\t";
    DFS(G, ch);
    cout << endl;
    cout << "广度遍历结果：\t";
    BFS(G, ch); 
    return 0;
}

结果如图