图是一种重要的数据结构，主要由顶点和边组成，一般根据边是否为双向分为无向图和有向图。

G1为无向图，G2为有向图。

1、深度优先遍历

假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻接点出发深度优先搜索遍历图，直至图中所有和v有路径相通的顶点都被访问到。 若此时尚有其他顶点未被访问到，则另选一个未被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。

G1 的深度优先遍历结果为A C B D F G E ，G2为A B C E D F G 

2、广度优先遍历

从图中某顶点v出发，在访问了v之后依次访问v的各个未曾访问过的邻接点，然后分别从这些邻接点出发依次访问它们的邻接点，并使得“先被访问的顶点的邻接点先于后被访问的顶点的邻接点被访问，直至图中所有已被访问的顶点的邻接点都被访问到。如果此时图中尚有顶点未被访问，则需要另选一个未曾被访问过的顶点作为新的起始点，重复上述过程，直至图中所有顶点都被访问到为止。

G1的广度优先遍历结果为A C D F B G E ，G2为A B C E F D G 

代码：

import java.util.LinkedList;
import java.util.Queue;

/**
 * 用邻接矩阵表示无向图
 */
public class MatrixNDG {
    int size;   //顶点个数
    String[] vertexes;  //顶点
    int[][] matrix; //邻接矩阵
    int[] visited;  //记录是否被访问

    public MatrixNDG(String[] vertexes, String[][] edges){
        size = vertexes.length;
        this.vertexes = vertexes;
        matrix = new int[size][size];
        visited = new int[size];

        for(int i=0;i<edges.length;i++){
            String point1 = edges[i][0];
            String point2 = edges[i][1];

            int position1 = getPosition(point1);
            int position2 = getPosition(point2);
            matrix[position1][position2] = 1;
            matrix[position2][position1] = 1;
        }
    }

    /**
     * 根据顶点名称获取对应的矩阵下标
     * @param point
     * @return
     */
    private int getPosition(String point){
        for(int i=0;i<vertexes.length;i++){
            if(vertexes[i].equals(point)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 重设visited矩阵，全部置为0
     */
    public void resetVisited(){
        for(int i=0;i<size;i++){
            visited[i] = 0;
        }
    }

    /**
     * 输出邻接矩阵
     */
    public void print() {
        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                System.out.print(matrix[i][j]+" ");
            }
            System.out.println();
        }
    }

    /**
     * 得到当前顶点K的第now个顶点之后的邻接顶点
     * @param k
     * @param now
     * @return
     */
    public int getAdjacentVertex(int k, int now){
        for(int i=now+1;i<size;i++){
            if (matrix[k][i]==1){
                return i;
            }
        }
        return -1;
    }

    /**
     * 深度优先遍历
     */
    public void DFS(int k){
        visited[k] = 1; //表示顶点K被访问过
        System.out.print(vertexes[k]+" ");
        int u = getAdjacentVertex(k,-1);    //得到顶点K的第一个邻接点
        while (u!=-1){
            if(visited[u]==0){
                DFS(u);
            }
            u = getAdjacentVertex(k,u); //得到顶点K的下一个邻接点
        }
    }

    /**
     * 广度优先遍历
     */
    public void BFS(int k){
        Queue<Integer> queue = new LinkedList<>();
        queue.add(k);   //将顶点K添加进队列
        visited[k] = 1; //表示顶点K被访问过
        int u;
        while (!queue.isEmpty()){
            u = queue.remove(); //去除队列顶元素
            System.out.print(vertexes[u]+" ");
            int v = getAdjacentVertex(u,-1);    //得到顶点K的第一个邻接点
            while (v!=-1){
                if(visited[v]==0){
                    queue.add(v);
                    visited[v] = 1;
                }
                v = getAdjacentVertex(u,v); //得到顶点K的下一个邻接点
            }
        }
    }
}

import java.util.LinkedList;
import java.util.Queue;

/**
 * 用邻接矩阵表示有向图
 */
public class MatrixDG {
    int size;
    String[] vertexes;
    int[][] matrix;
    int[] visited;

    public MatrixDG(String[] vertexes, String[][] edges){
        size = vertexes.length;
        this.vertexes = vertexes;
        matrix = new int[size][size];
        visited = new int[size];

        for(int i=0;i<edges.length;i++){
            String point1 = edges[i][0];
            String point2 = edges[i][1];

            int position1 = getPosition(point1);
            int position2 = getPosition(point2);
            matrix[position1][position2] = 1;
        }

        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                if(matrix[i][j]!=1){
                    matrix[i][j] = 0;
                }
            }
        }
    }

    /**
     * 根据顶点名称获取对应的矩阵下标
     * @param point
     * @return
     */
    public int getPosition(String point){
        for(int i=0;i<vertexes.length;i++){
            if(vertexes[i].equals(point)){
                return i;
            }
        }
        return -1;
    }

    /**
     * 重设visited矩阵，全部置为0
     */
    public void resetVisited(){
        for(int i=0;i<size;i++){
            visited[i] = 0;
        }
    }

    /**
     * 输出邻接矩阵
     */
    public void print() {
        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                System.out.print(matrix[i][j]+" ");
            }
            System.out.println();
        }
    }

    /**
     * 得到当前顶点K的第now个顶点之后的邻接顶点
     * @param k
     * @param now
     * @return
     */
    public int getAdjacentVertex(int k, int now){
        for(int i=now+1;i<size;i++){
            if (matrix[k][i]==1){
                return i;
            }
        }
        return -1;
    }

    /**
     * 深度优先遍历
     */
    public void DFS(int k){
        visited[k] = 1; //表示顶点K被访问过
        System.out.print(vertexes[k]+" ");
        int u = getAdjacentVertex(k,-1);    //得到顶点K的第一个邻接点
        while (u!=-1){
            if(visited[u]==0){
                DFS(u);
            }
            u = getAdjacentVertex(k,u); //得到顶点K的下一个邻接点
        }
    }

    /**
     * 广度优先遍历
     */
    public void BFS(int k){
        Queue<Integer> queue = new LinkedList<>();
        queue.add(k);   //将顶点K添加进队列
        visited[k] = 1; //表示顶点K被访问过
        int u;
        while (!queue.isEmpty()){
            u = queue.remove(); //去除队列顶元素
            System.out.print(vertexes[u]+" ");
            int v = getAdjacentVertex(u,-1);    //得到顶点K的第一个邻接点
            while (v!=-1){
                if(visited[v]==0){
                    queue.add(v);
                    visited[v] = 1;
                }
                v = getAdjacentVertex(u,v); //得到顶点K的下一个邻接点
            }
        }
    }
}