A | B | C | D | E | |

A | 0 | 1 | 1 | 0 | 0 |

B | 1 | 0 | 1 | 1 | 1 |

C | 1 | 1 | 0 | 0 | 0 |

D | 0 | 1 | 0 | 0 | 0 |

E | 0 | 1 | 0 | 0 | 0 |

// explain

//1 indicates that it can be connected directly, and 0 indicates that it cannot be connected directly

Depth first search process:

A-B-C-D-E,A, B and C can be connected, and the connection is "1"; B is connected with a, C, D and E; C is connected with a and B; D and B connect, e and B connect.

A connects to B. after finding B, B connects to C. C can't connect to other nodes, so it returns to B, B connects to D and B connects to E. (when you find a point, it doesn't change, and one road goes to black).

code:

/Get the subscript of the first node public int getfirstNeighbor(int index){ for(int j=0;j<vertexList.size();j++){ if(edges[index][j]>0){ return j; } } return -1; } //The next adjacent node is obtained according to the subscript of the previous adjacent node public int getNextNeighbor(int v1,int v2){ for(int j=v2+1;j<vertexList.size();j++){ if(edges[v1][j]>0){ return j; } } return -1; } //Depth first traversal /* isVisited[] An array that records whether a node accesses * i The first time is 0 */ public void dfs(boolean[] isVisited,int i){ //First access the node and output System.out.print(getValueByIndex(i)+"->"); isVisited[i]=true; int w=getfirstNeighbor(i); while(w!=-1){ //Indicates that there are adjacent nodes if(!isVisited[w]){ dfs(isVisited,w); } //If the node is accessed w=getNextNeighbor(i,w); } } //Overloaded dfs method public void dfs(){ isVisited=new boolean[vertexList.size()]; //Traverse all nodes for dfs backtracking for(int i=0;i<vertexList.size();i++){ if(!isVisited[i]){ dfs(isVisited,i); } } }

2, Breadth first traversal of graphs (BFS)

The basic idea of breadth first traversal is similar to a hierarchical search process. A queue needs to be used to maintain the order of visited nodes, so as to access the leading nodes of these nodes in this order.

Algorithm steps:

1 access the initial node v and mark that node v has been accessed

2 node v in queue

3 when the queue is not empty, continue to execute, otherwise the algorithm will end

4. Get out of the queue and get the queue head node u

5 find the first collar node v of node u

6 if the collar node w of node u does not exist, move to step 3, otherwise cycle through the following three steps

6.1 if node w has not been accessed, access node W and mark it as accessed

6.2 node w in queue

6.3 find the next collar node after the w collar node of node u and transfer to step 6

The search process is as follows:

A finds B and then finds the successor node C of B. A can find C. at this time, B pops up B in the queue and finds it from node B. at this time, node a has been accessed, and C has also been accessed. At this time, D has been accessed, and E can also be accessed

That is, B and C are accessed by A, and D and E are accessed by A node.

//breadth-first search public void bfs(boolean isVisited[],int i){ int u; //Indicates the subscript corresponding to the head node of the queue int w; //Adjacency node //Queue, which records the order of accessing nodes LinkedList queue=new LinkedList(); //Output access node information System.out.println(getValueByIndex(i)+"->"); //Mark as accessed isVisited[i]=true; //Add an accessed node to the queue queue.addLast(i); while(!queue.isEmpty()){ //Fetch the subscript of the header node of the queue u=(Integer)queue.removeFirst(); //Get the subscript of the first adjacent node w=getfirstNeighbor(u); while(w!=-1){ //Have you visited if(!isVisited[w]){ System.out.println(getValueByIndex(w)+"->"); //Mark as accessed isVisited[w]=true; //Join the team queue.addLast(w); } //Take u as the leading point and find the next node after w w=getNextNeighbor(u,w); } } } //Traverse all nodes and perform breadth first search public void bfs(){ isVisited=new boolean[vertexList.size()]; for(int i=0;i<vertexList.size();i++){ if(!isVisited[i]){ bfs(isVisited,i); } } }

get!