java学习笔记（数据结构与算法10）图的基本方法实现，深度优先搜索dfs，广度优先搜索bfs实现，java代码带注释。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class Map {
    public static void main(String[] args) {
        Graph graph=new Graph(8);
        String vertexs[]={"1","2","3","4","5","6","7","8"};
        for(String vertex:vertexs){
            graph.addVertex(vertex);
        }
        graph.addEdges(0,1,1);
        graph.addEdges(0,2,1);
        graph.addEdges(1,2,1);
        graph.addEdges(1,3,1);
        graph.addEdges(1,4,1);
        graph.addEdges(3,7,1);
        graph.addEdges(4,7,1);
        graph.addEdges(2,5,1);
        graph.addEdges(2,6,1);
        graph.addEdges(5,6,1);
        graph.print();
        System.out.println(graph.getEdgeNum());
        graph.dfs();
        graph.bfs();
    }
}
class Graph{
    private List<String> vertexList;//存储顶点的集合
    private int[][] edges;//存储边，值作为边的weight
    private int edgeNum;
    public Graph(){
    }
    //构造方法，初始化实例变量，edges的大小由传入的参数决定
    public Graph(int n){
        vertexList=new ArrayList<>();
        edges=new int[n][n];
    }
    //添加顶点
    public void addVertex(String s){
        vertexList.add(s);
    }
    //添加边，如果边已经存在，则更新边的weight
    public void addEdges(int m,int n,int weight){
        edges[m][n]=weight;
        edges[n][m]=weight;
        edgeNum++;
    }
    public void print(){
        for(int[] temp:edges){
            System.out.println(Arrays.toString(temp));
        }
    }
    //返回边的个数
    public int getEdgeNum(){
        return edgeNum;
    }
    //返回第一个邻居节点的索引编号
    public int firstNeighbor(int index){
        for(int i=0;i<vertexList.size();i++){
            if(edges[index][i]!=0){
                return i;
            }
        }
        return -1;
    }
    //返回下一个邻居节点的索引编号
    public int nextNeighbor(int index,int front){
        for(int i=front+1;i<vertexList.size();i++){
            if(edges[index][i]!=0){
                return i;
            }
        }
        return -1;
    }
    //重载函数，要对每个没有访问过的节点进行深度优先遍历
    public void dfs(){
        boolean[] isVisited=new boolean[vertexList.size()];
        for(int i=0;i<isVisited.length;i++){
            if(!isVisited[i]){
                dfs(i,isVisited);
            }
        }
        System.out.println("深度优先遍历");
    }
    //对索引编号为n的节点进行深度优先遍历
    public void dfs(int n,boolean[] isVisited){
        //访问当前节点，输出并标记为true
        System.out.print(vertexList.get(n)+"->");
        isVisited[n]=true;
        int w=nextNeighbor(n,0);
        while(w!=-1){
            //如果w没有访问过，就访问w
            if(!isVisited[w]) {
                dfs(w, isVisited);
            }
            w=nextNeighbor(n,w);
        }
    }
    //广度优先遍历
    public void bfs(){
        boolean[] isVisited=new boolean[vertexList.size()];
        //定义一个队列，每次访问队列的第一个未被访问过的数据，并将访问的该数据的邻居全部存入数列。
        LinkedList<Integer> queue=new LinkedList<>();
        for(int i=0;i<isVisited.length;i++){
            if(!isVisited[i]){
                bfs(i,isVisited,queue);
            }
        }
        System.out.println("广度优先遍历");
    }
    public void bfs(int n,boolean[] isVisited,LinkedList<Integer> queue){
        System.out.print(vertexList.get(n)+"->");
        isVisited[n]=true;
        int w=nextNeighbor(n,0);
        while(w!=-1){
            queue.addLast(w);
            w=nextNeighbor(n,w);
        }
        if(!queue.isEmpty()){
            int temp=queue.removeFirst();
            if(!isVisited[temp])
            bfs(temp,isVisited,queue);
        }
    }

}

运行结果：