(c#) Implementar algoritmos de búsqueda de profundidad y amplitud para gráficos

void BFS(ALGraph *G,int v)

{

ArcNode *p;

int queue[MAXV],front=0,rear=0; //definir la cola circular e inicializarla

int wanted[MAXV] //definir la matriz que contiene las banderas de visita de los nodos

int w,i;

for (i=0;i<G->n;i++) visited[i]=0 //Inicializar matriz de indicadores de acceso

printf("%2d",v); //Ingresa el número del vértice visitado

visitado[v]=1 //Coloca la marca visitada

rear =(rear+1)%MAXV;

queue[rear]=v; //v ingresa a la cola

while (front!=rear) // bucle si la cola no está vacío

{ front=(front+1)%MAXV;

w=queue[front] // fuera de la cola y asigne a w

p=G->adjlist[w].firstarc; //encuentra el primer vértice vecino al vértice w

while (p!=NULL)

{ if (visited[ p- >adjvex]==0) //si el vértice vecino actual no es visitado

{ printf("%2d",p->adjvex); //visita los vértices vecinos

visited[p->adjvex]=1; //establece el indicador de que este vértice ha sido visitado flag

rear=(rear+1)%MAXV;

queue[rear]=p->adjvex;

}

p=p->nextarc; //busca el siguiente vértice vecino

}

}

}

printf("\n"); void main ()

{

int i,j;

MGraph g;

ALGraph *G;

int A[MAXV][5]={

{0,1.0,1,1},

{1,0,1,1,0},

{0,1,0,1,1},

{1,1,1,0,1},

{1,0,1, 1, 0}};

g.n=5;g.e=16;

para (i=0;i

para (j =0;j

g.edges[i][j]=A[i

][j];

G=(ALGraph *)malloc(sizeof(ALGraph));

MatToList(g,G);

printf(" Tabla de adyacencia:\ n");DispAdj(G);

printf("Amplitud-primera secuencia:");BFS(G,2);printf("\n");

}

Lo anterior es un recorrido de búsqueda en amplitud

#include "exam8-2.cpp "

int visited[MAXV];

void DFS(ALGraph *G,int v)

{

ArcNode *p;

visitado[v]=1 //establecer marcador visitado;

printf("%d ",v); // genera el número del vértice visitado

p=G->adjlist[v].firstarc //p apunta a el primer arco del vértice v El nodo principal de un arco

while (p. =NULL)

p=G->adjlist[v]! =NULL)

{

if (visited[p->adjvex]==0) // Si el vértice p->adjvex no ha sido visitado, accede a él de forma recursiva

DFS(G,p->adjvex);

p=p->nextarc; // p apunta al nodo principal del siguiente arco del vértice v

}

}

void main()

{

int i,j

MGraph g; ;

ALGraph *G;

int A[MAXV][5]={

{0,1,0,1,1},

{1,0,1,1,0},

{0,1,0,1,1},<

{1,1,1 ,0 ,1},

{1,0,1,1,0}};

g.n=5;g.e=16;

para ( i= 0;i

para (j=0;j

g.edges[i ][j]=A[i] [j ];

G=(ALGraph *)malloc(sizeof(ALGraph));

MatToList(g,G);

printf(" Vecindario Tabla: \n");DispAdj(G);

for (i=0;i& lt;MAXV;i++)

visitado[i]=0;

printf("Primera secuencia en profundidad:");DFS(G,2);printf("\n");

}

Esta es una búsqueda en profundidad recorrido.

Específicamente, cuando sabes cómo operar, aún necesitas innovar