图（概念，深度优先遍历，广度优先遍历）

基本概念

 （5）有向图：顶点的连接有方向，比如只能A->B，不能B->A

   (6)  带权图：边带权值

邻接矩阵：

邻接表： 

 图的遍历：

从已知的连通图的某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次。

深度优先遍历（DFS）：

//DFS
    public void DFS(int[][] edges,int v){
        System.out.println(getValueByIndex(v));
        isVisited[v]=true;
        for (int w=0;w<vertexList.size();w++){
            if (edges[v][w]!=0&&(!isVisited[w]))
                DFS(edges,w);
        }
    }
    //对DFS进行重载,避免非联通结点没有遍历到
    public void DFS(){
        for (int i=0;i<vertexList.size();i++){
            if (!isVisited[i])
                DFS(edges,i);
        }
    }

广度优先遍历（BFS）：

从第一结点出发，找到未被访问过的邻接结点，则将该结点入队列；将一个结点遍历完后，出队列；再从队列头出发找邻接结点，直至队列为空。

//BFS，利用队列实现（注意队列加从尾部加，取从头部取）
    public void BFS (int v){
        LinkedList<Integer> queue = new LinkedList<Integer>();
        System.out.println(getValueByIndex(v));
        isVisited[v]=true;
        queue.add(v);
        while (!queue.isEmpty()){
            Integer front = queue.poll();
            for (int i=0;i<vertexList.size();i++){
                if (edges[front][i]!=0&&(!isVisited[i])){
                    queue.add(i);
                    System.out.println(getValueByIndex(i));
                    isVisited[i]=true;
                }
            }
        }
    }
    //BFS重载，避免非联通结点没有遍历到
    public void BFS(){
        for (int i=0;i<vertexList.size();i++){
            if (!isVisited[i])
                BFS(i);
        }
    }

全部代码：

public class Graph1 {
    private ArrayList<String> vertexList;
    private int[][] edges;
    private int numOfEdges;
    //定义数组boolean[],记录某个结点是否被访问过
    private boolean[] isVisited;

    public static void main(String[] args) {
        int n = 5;
        String VertexValue[] = {"A", "B", "C", "D", "E"};
        Graph1 graph1 = new Graph1(n);
        for (String str : VertexValue) {
            graph1.insertVertex(str);
        }
        //添加边
        graph1.insertEdge(0, 1, 1);
        graph1.insertEdge(0, 2, 1);
        graph1.insertEdge(1, 2, 1);
        graph1.insertEdge(1, 3, 1);
        graph1.insertEdge(1, 4, 1);

        //显示
        graph1.showGraph();

        //深度遍历
        System.out.println("******");
        graph1.BFS(0);

    }

    //构造器
    public Graph1(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
        isVisited = new boolean[n];
    }

    //显示图对应的矩阵
    public void showGraph() {
        for (int[] link : edges)
            System.out.println(Arrays.toString(link));
    }
    //DFS
    public void DFS(int[][] edges,int v){
        System.out.println(getValueByIndex(v));
        isVisited[v]=true;
        for (int w=0;w<vertexList.size();w++){
            if (edges[v][w]!=0&&(!isVisited[w]))
                DFS(edges,w);
        }
    }
    //对DFS进行重载,避免非联通结点没有遍历到
    public void DFS(){
        for (int i=0;i<vertexList.size();i++){
            if (!isVisited[i])
                DFS(edges,i);
        }
    }
    //BFS，利用队列实现（注意队列加从尾部加，取从头部取）
    public void BFS (int v){
        LinkedList<Integer> queue = new LinkedList<Integer>();
        System.out.println(getValueByIndex(v));
        isVisited[v]=true;
        queue.add(v);
        while (!queue.isEmpty()){
            Integer front = queue.poll();
            for (int i=0;i<vertexList.size();i++){
                if (edges[front][i]!=0&&(!isVisited[i])){
                    queue.add(i);
                    System.out.println(getValueByIndex(i));
                    isVisited[i]=true;
                }
            }
        }
    }
    //BFS重载，避免非联通结点没有遍历到
    public void BFS(){
        for (int i=0;i<vertexList.size();i++){
            if (!isVisited[i])
                BFS(i);
        }
    }