数据结构（十二）---图

基本介绍

（1）为什么要有图
1）前面我们学习了线性表和树
2）现行变局限于一个直接前驱和一个直接后继的关系
3）树也只能有一个直接前驱也就是父节点
4）当我们需要表示多对多的关系时，这里我们就用得到了图

（2）图的举例说明
图示一种数据结构，其中节点可以具有零个或者多个相邻元素，两个节点之间的连接称为边，节点也可以称为顶点

（3）图的常用概念
1）顶点
2）边
3）路径
4）无向图：顶点之间的连接没有方向
5）有向图
6）带权图

（4）图的表示方式
图的表示方式有两种：二维数组表示（邻接矩阵），链表表示（邻接表）
1-邻接矩阵
邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵的row和col表示的是1…n个点

（5）图的深度优先遍历介绍
所谓图的遍历，就是对节点的访问，一个图有那么多个节点，如何遍历这些节点，需要特定的策略
一般有两种访问策略：
1-深度优先遍历
2-广度优先遍历

1）图的深度优先遍历
1-深度优先遍历，从初始访问节点出发，初始访问节点可能有多个邻接节点，深度优先遍历的策略就是首先访问第一个邻接节点
深度优先遍历的策略就是首先访问第一个邻接节点，然后再以这个被访问的邻接节点作为初始节点，访问它的第一个邻接节点
可以这么理解：每次都在访问完当前节点后首先访问当前节点的第一个邻接节点
2-我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个节点的所有邻接节点进行横向访问
3-深度优先搜索是一个递归的过程

深度优先遍历算法步骤
1-访问初始节点v，并且标记节点v为已访问
2-查找节点v的第一个邻接节点w
3-若w存在，则继续执行4，如果w不存在，则返回到第1步，从v的下一个节点继续
4-若w未被访问，对w进行深度优先遍历递归（也就是把w节点当做又一个v节点，递归执行上述123步骤）
5-查找节点v的w邻接节点的下一个邻接节点，转到步骤3

2）图的广度优先遍历
类似于一个分层搜索的过程，广度优先遍历需要使用一个队列一保持访问过的节点的顺序，以便按这个顺序来访问这些节点的邻接节点

广度优先遍历算法步骤
1-访问初始节点v并且标记节点v为已访问
2-节点v入队列
3-当队列非空时，继续执行，否则算法结束
4-出队列，取得队头节点u
5-查找节点u的第一个邻接节点w
6-若节点u的邻接节点w不存在，则转到步骤3，否则循环执行以下三个步骤
6.1-若节点w还没有被访问，则访问节点w并标记为已访问
6.2-节点w入队列
6.3-查找节点u的继w邻接节点后的下一个邻接节点w，转到步骤6

总结一下：
遍历依据的是“邻接矩阵”
从矩阵的第一行开始，找到第一个节点
如果是深度优先，那就是先从第一行找1，找到一个以后，就换一行，用刚才找到的那个节点接着找当前行
如果是广度优先，那就是先从第一行找1，并且把第一行找完为止

创建图并测试

public class Graph {

    private ArrayList<String> vertexList;//存储顶点的集合
    private int[][] edges;//存储图对应的邻接矩阵
    private int numofEdges;//表示边的个数

    //定义给数组boolean[]，记录某个节点是否被访问
    private boolean[] isVisited;

    public static void main(String[] args) {
        //测试一把图是否创建ok
        int n = 5;//节点的个数
        String Vertexs[] = {"A", "B", "C", "D", "E"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环的添加顶点
        for (String vertexValue : Vertexs) {
            graph.insertVertex(vertexValue);
        }
        //添加边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);

        //测试显示一把邻接矩阵
        graph.showGraph();

        //测试一把深度遍历dfs
        System.out.println("深度优先遍历：");
        graph.dfs();//A-B-C-D-E
        System.out.println();
        //测试一把广度优先bfs
        System.out.println("广度优先遍历：");
        graph.bfs();//A-B-C-D-E

    }

    /**
     * 构造器
     *
     * @MethodName: Graph
     * @Author: AllenSun
     * @Date: 2019/11/15 20:50
     */
    public Graph(int n) {
        //初始化矩阵和vertexList
        edges = new int[n][n];//创建一个n*n的矩阵
        vertexList = new ArrayList<String>(n);
        numofEdges = 0;
    }

    /**
     * 得到第一个邻接节点的下标w（开始准备深度遍历）
     * 横向向下寻找节点，先找到第一个邻接节点，然后再找下一个
     * 如果能找到就返回对应的下标，找不到就返回-1
     *
     * @MethodName: getFirstNeighbor
     * @Author: AllenSun
     * @Date: 2019/11/15 21:44
     */
    public int getFirstNeighbor(int index) {
        for (int i = 0; i < vertexList.size(); i++) {
            //判断
            if (edges[index][i] > 0) {
                //说明下一个节点是存在的
                return i;
            }
        }
        //否则返回一个-1
        return -1;
    }
    //

    /**
     * 根据前一个邻接节点的下标来获取下一个邻接节点
     * 上面已经找了第一个邻接节点，接下来就是顺着往下找了
     *
     * @MethodName: getNextNeighbor
     * @Author: AllenSun
     * @Date: 2019/11/15 21:49
     */
    public int getNextNeighbor(int v1, int v2) {
        for (int i = v2 + 1; i < vertexList.size(); i++) {
            if (edges[v1][i] > 0) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 深度遍历
     * 方法传入的参数是“数组isVisited”和下标“i”
     * isVisited表示的是布尔型数组，记录的是某个节点有没有被访问过，如果访问过就绕过了
     * i就是节点的下标
     * 方法通过这两个参数开始访问初始节点，并且标记节点为已访问
     *
     * @MethodName: dfs
     * @Author: AllenSun
     * @Date: 2019/11/15 21:51
     */
    public void dfs(boolean[] isVisited, int i) {
        //1-访问初始节点v，并且标记节点v为已访问
        //    首先访问该节点，也就是输出这个节点
        System.out.print(getValueByIndex(i) + "->");
        //    把上面访问了的节点设为已访问
        isVisited[i] = true;
        //2-查找节点v的第一个邻接节点w
        //找到下标为i的节点的下一个邻接节点
        int w = getFirstNeighbor(i);
        //如果w不为-1，就说明找到了下一个邻接节点
        while (w != -1) {
            //有邻接节点，但是要判断一下是不是已经被访问过了
            if (!isVisited[w]) {
                //如果被有被访问过，那就对w进行深度优先遍历递归，开始递归重复上述步骤
                dfs(isVisited, w);
            }
            //如果w节点已经被访问过了，那就应该查找w的下一个邻接节点
            w = getNextNeighbor(i, w);
        }
    }

    //对dfs进行重载，上面的dfs没有实现一种情况：当下一个邻接节点w不存在的时候，就要返回第一步
    //遍历我们所有的节点，并且进行dfs
    public void dfs() {
        isVisited = new boolean[5];
        //遍历所有的节点，进行dfs[回溯]
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    /**对一个节点进行图的广度优先遍历
     * 只针对一个节点，并不是针对全部节点
     * @MethodName: bfs
     * @Author: AllenSun
     * @Date: 2019/11/15 23:29
     */
    public void bfs(boolean[] isVisited, int i) {
        int u;//表示队列的头结点对应下标
        int w;//节点u的第一个邻接节点w
        //需要一个队列，用LinkedList来实现队列，在广度遍历时，先遍历邻接矩阵第一行，要把这一行遍历到的节点入队列
        LinkedList queue = new LinkedList();
        //访问结点，输出
        System.out.print(getValueByIndex(i) + "->");
        //标记为已访问
        isVisited[i] = true;
        //将节点加入队列
        queue.addLast(i);
        while (!queue.isEmpty()) {
            //取出队列的头结点下标
            u = (Integer) queue.removeFirst();
            //得到第一个邻接节点的下标w
            w = getFirstNeighbor(u);
            while (w != -1) {
                //不为-1，说明这个节点能够找到
                //判断是否访问过
                if (!isVisited[w]) {
                    System.out.print(getValueByIndex(w) + "->");
                    //标记已经访问
                    isVisited[w] = true;
                    //访问后入队列
                    queue.addLast(w);
                }
                //以u为前驱节点，找w后面的下一个邻接点
                w = getNextNeighbor(u, w);//体现出我们的广度优先
            }
        }
    }
    //遍历所有的节点，都进行广度优先搜索，重载bfs方法
    public void bfs(){
        isVisited = new boolean[5];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if(!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }


    //图中常用的方法

    /**
     * 返回节点的个数
     *
     * @MethodName: getNumOfVertex
     * @Author: AllenSun
     * @Date: 2019/11/15 20:50
     */
    public int getNumOfVertex() {
        return vertexList.size();
    }

    /**
     * 显示图对应的矩阵
     *
     * @MethodName: showGraph
     * @Author: AllenSun
     * @Date: 2019/11/15 20:50
     */
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * 得到边的数目
     *
     * @MethodName: getNumofEdges
     * @Author: AllenSun
     * @Date: 2019/11/15 20:50
     */
    public int getNumofEdges() {
        return numofEdges;
    }

    /**
     * 返回节点i下标对应的数据
     *
     * @MethodName: getValueByIndex
     * @Author: AllenSun
     * @Date: 2019/11/15 20:51
     */
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    /**
     * 返回v1和v2,的权值
     *
     * @MethodName: getWeight
     * @Author: AllenSun
     * @Date: 2019/11/15 20:51
     */
    public int getWeight(int v1, int v2) {
        return edges[v1][v2];
    }

    /**
     * 插入节点
     *
     * @MethodName: insertVertex
     * @Author: AllenSun
     * @Date: 2019/11/15 20:51
     */
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    /**
     * 添加边
     *
     * @MethodName: insertEdge
     * @Author: AllenSun
     * @Date: 2019/11/15 20:52
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numofEdges++;
    }
}