数据结构和算法学习笔记七_图

数据结构和算法学习笔记七_图

学习视频：尚硅谷韩老师Java讲解数据结构与算法

一、基本介绍

1.1、图的基本概念：

图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图：

1.2、图的常用概念：

1. 顶点(vertex)
2. 边(edge)
3. 路径
4. 无向图：

5. 有向图：
   

6. 带权图：

1.3、图的表示方式：

图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。

1. 邻接矩阵

   邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于n个顶点的图而言，矩阵是的row和col表示的是1…n个点。

2. 邻接表

邻接矩阵需要为每个顶点都分配n个边的空间，其实有很多边都是不存在,会造成空间的一定损失.
邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成

二、快速入门

2.1、图的快速入门案例

1. 要求: 代码实现如下图结构.

2. 思路分析 (1) 存储顶点String 使用 ArrayList (2) ,保存矩阵 int[][] edges

3. 代码实现

   package com.lxf.graph;
   
   import java.util.ArrayList;
   
   public class Graph {
         
         
       private ArrayList<String> vertexList;//存储顶点集合
       private int[][] edges;//存储图对应的邻接矩阵
       private int numOfEdge;//表示边的数目
   
   
       public static void main(String[] args) {
         
         
           //测试一把图是否创建成功
           int n=5;//结点的个数
           String vertexValue[]={
         
         "A","B","C","D","E"};
           //创建图对象
           Graph graph = new Graph(n);
           //循环添加顶点
           for (String  value:vertexValue){
         
         
               graph.insertVertex(value);
           }
           //添加边
           //A-B A-C B-C B-D B-E
           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();
       }
   
       /**
        * 构造器：初始化邻接矩阵和顶点集合
        * @param n ：顶点数
        */
       public Graph(int n) {
         
         
           this.edges =new int[n][n];
           vertexList=new ArrayList<String>();
       }
   
       /**
        * 返回结点的个数
        * @return
        */
       public int getNumOfVertex(){
         
         
           return vertexList.size();
       }
       /**
        * 返回边的条个数
        * @return
        */
       public int getNumOfEdge(){
         
         
           return numOfEdge;
       }
       /**
        * 返回结点i(下标)对应的数据0->"A" 1->"B" 2->"C"
        * @return
        */
       public String getValueByIndex(int i){
         
         
           return vertexList.get(i);
       }
   
       /**
        * 显示图对应的矩阵
        */
       public void showGraph(){
         
         
           for (int[] edge : edges) {
         
         
               for (int i : edge) {
         
         
                   System.out.print(i+" ");
               }
               System.out.println();
           }
       }
       /**
        * 返回坐标对应的权值
        * @param v1
        * @param v2
        * @return
        */
       public int getWeight(int v1,int v2){
         
         
           return edges[v1][v2];
       }
       /**
        * 插入结点
        * @param vertex
        */
       public void insertVertex(String vertex){
         
         
           vertexList.add(vertex);
       }
   
       /**
        * 添加边
        * @param v1 表示第一个点的下标
        * @param v2 表示第二个点的下标
        *           比如：A对应v1且值为0,B对应v2且值为1
        * @param weight
        */
       public void insertEdge(int v1,int v2,int weight){
         
         
           edges[v1][v2]=weight;
           edges[v2][v1]=weight;
           numOfEdge++;
       }
   }
   
   

三、图的深度优先遍历

3.1、图遍历介绍

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种访问策略: (1)深度优先遍历 (2)广度优先遍历

3.2、深度优先遍历基本思想

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

3.3、深度优先遍历算法步骤

1. 访问初始结点v，并标记结点v为已访问。
2. 查找结点v的第一个邻接结点w。
3. 若w存在，则继续执行4，如果w不存在，则回到第1步，将从v的下一个结点继续。
4. 若w未被访问，对w进行深度优先遍历递归（即把w当做另一个v，然后进行步骤123）。
5. 查找结点v的w邻接结点的下一个邻接结点，转到步骤3。

3.4、具体案例：

1. 要求：对下图进行深度优先搜索, 从A 开始遍历.

2. 思路分析

2.1、定义isVisited的boolean数组，大小为5，全部为false,表示五个顶点均未访问

2.2、从0也就是顶点A开始，输出A,且标记A已访问，A对应的第一个顶点是B，未被访问，继续下一步

2.3、再从B开始，输出B，且标记B已访问，B对应的第一个顶点是A，已被访问，再搜索B指向的下一个顶点C，搜未被访问，继续下一步。

2.4、再从C开始，输出C，且标记C已访问，C对应的第一个顶点是A，已被访问，再搜索C指向的下一个顶点B，已访问，且C没有下一个指向的顶点了，回溯到A顶点，也没有，回溯到B顶点，B顶点有指向的未被访问的顶点D，继续下一步

2.5、再从D开始，输出D，且标记D已访问，D对应的第一个顶点是B，已被访问，且D没有下一个指向的顶点了，再次回溯到B顶点，B顶点有指向的未被访问的顶点E，继续下一步

2.6、再从E开始，输出E，且标记E已访问，E对应的第一个顶点是B，已被访问，且E没有下一个指向的顶点了,全部执行完毕，输出结果为：A->B->C->D->E->

3. 代码实现

package com.lxf.graph;

import java.util.ArrayList;

public class Graph {
    
    
    private ArrayList<String> vertexList;//存储顶点集合
    private int[][] edges;//存储图对应的邻接矩阵
    private int numOfEdge;//表示边的数目
    //定义一个boolean数组，记录某个结点是否被访问
    private boolean[] isVisited;

    public static void main(String[] args) {
    
    
        //测试一把图是否创建成功
        int n=5;//结点的个数
        String vertexValue[]={
    
    "A","B","C","D","E"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String  value:vertexValue){
    
    
            graph.insertVertex(value);
        }
        //添加边
        //A-B A-C A-D A-E B-E
        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(graph.isVisited,0);
    }

    /**
     * 构造器：初始化邻接矩阵和顶点集合
     * @param n ：顶点数
     */
    public Graph(int n) {
    
    
        this.edges =new int[n][n];
        vertexList=new ArrayList<String>();
        isVisited=new boolean[5];
    }

    /**
     * 获取第一个邻接结点的下标
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    public int getFirstNeighbor(int index){
    
    
        for (int i = 0; i < vertexList.size(); i++) {
    
    
            if(edges[index][i]>0){
    
    
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据前一个邻接结点的下标来获取下一个邻接结点
     * @param v1
     * @param v2
     * @return
     */
    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;
    }

    /**
     * 深度优先遍历方法
     * i 第一次就是0
     */
    private void dfs(boolean[] isVisited,int i){
    
    
        //首次访问该结点，输出
        System.out.print(getValueByIndex(i)+"->");
        //将结点设置为已访问
        isVisited[i]=true;

        //获取当前结点i的第一个邻接结点w
        int w=getFirstNeighbor(i);
        while (w!=-1){
    
    //说明有
            if(!isVisited[w]){
    
    
                dfs(isVisited, w);
            }
            //如果w结点已经被访问过，
            w=getNextNeighbor(i,w);
        }

    }

    /**
     * 对dfs进行一个重载，遍历我们所有的结点，并进行dfs
     */
    // public void dfs(){
    
    
    //     //遍历所有的结点，进行dfs[回溯]
    //     for (int i = 0; i < getNumOfVertex(); i++) {
    
    
    //         if(!isVisited[i]){
    
    
    //             dfs(isVisited, i);
    //         }
    //     }
    // }
    /**
     * 返回结点的个数
     * @return
     */
    public int getNumOfVertex(){
    
    
        return vertexList.size();
    }
    /**
     * 返回边的条个数
     * @return
     */
    public int getNumOfEdge(){
    
    
        return numOfEdge;
    }
    /**
     * 返回结点i(下标)对应的数据0->"A" 1->"B" 2->"C"
     * @return
     */
    public String getValueByIndex(int i){
    
    
        return vertexList.get(i);
    }

    /**
     * 显示图对应的矩阵
     */
    public void showGraph(){
    
    
        for (int[] edge : edges) {
    
    
            for (int i : edge) {
    
    
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
    /**
     * 返回坐标对应的权值
     * @param v1
     * @param v2
     * @return
     */
    public int getWeight(int v1,int v2){
    
    
        return edges[v1][v2];
    }
    /**
     * 插入结点
     * @param vertex
     */
    public void insertVertex(String vertex){
    
    
        vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 表示第一个点的下标
     * @param v2 表示第二个点的下标
     *           比如：A对应v1且值为0,B对应v2且值为1
     * @param weight
     */
    public void insertEdge(int v1,int v2,int weight){
    
    
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdge++;
    }
}

四、图的广度优先遍历

4.1、广度优先遍历基本思想

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

4.2、广度优先遍历算法步骤

1. 访问初始结点v并标记结点v为已访问。
2. 结点v入队列
3. 当队列非空时，继续执行，否则算法结束。
4. 出队列，取得队头结点u。
5. 查找结点u的第一个邻接结点w。
6. 若结点u的邻接结点w不存在，则转到步骤3；否则循环执行以下三个步骤：
   • 若结点w尚未被访问，则访问结点w并标记为已访问。
   • 结点w入队列
   • 查找结点u的继w邻接结点后的下一个邻接结点w，转到步骤6。

4.3、广度优先举例说明

4.4、广度优先算法的代码实现

package com.lxf.graph;

import java.util.ArrayList;
import java.util.LinkedList;

public class Graph {
    
    
    private ArrayList<String> vertexList;//存储顶点集合
    private int[][] edges;//存储图对应的邻接矩阵
    private int numOfEdge;//表示边的数目
    //定义一个boolean数组，记录某个结点是否被访问
    private boolean[] isVisited;

    public static void main(String[] args) {
    
    
        //测试一把图是否创建成功
        int n=5;//结点的个数
        String vertexValue[]={
    
    "A","B","C","D","E"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String  value:vertexValue){
    
    
            graph.insertVertex(value);
        }
        //添加边
        //A-B A-C A-D A-E B-E
        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();

        System.out.println("广度优先：");
        graph.bfs();
    }

     /**
     * 构造器：初始化邻接矩阵和顶点集合
     * @param n ：顶点数
     */
    public Graph(int n) {
    
    
        this.edges =new int[n][n];
        vertexList=new ArrayList<String>();
        isVisited=new boolean[n];
    }

    /**
     * 获取第一个邻接结点的下标
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-1
     */
    public int getFirstNeighbor(int index){
    
    
        for (int i = 0; i < vertexList.size(); i++) {
    
    
            if(edges[index][i]>0){
    
    
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据前一个邻接结点的下标来获取下一个邻接结点
     * @param v1
     * @param v2
     * @return
     */
    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;
    }


    /**
     * bfs
     * @param isVisited
     * @param i
     */
    private void bfs(boolean[] isVisited,int i){
    
    
        int u;//表示队列的头节点对应的下标
        int w;//邻接结点w

        //得到第一个邻接结点的下标w
        w=getFirstNeighbor(i);
        while (w!=-1){
    
    //找到
            //是否访问过
            if (!isVisited[w]) {
    
    
                System.out.print(getValueByIndex(w)+"=>");
                //标记已经访问
                isVisited[w]=true;
            }
            //以u为前驱点，找w后面的下一个邻接点
            w=getNextNeighbor(i,w);
        }
    }

    /**
     * 遍历所有的结点，都进行广度优先搜索
     */
    public void bfs(){
    
    
        System.out.print(getValueByIndex(0)+"=>");
        isVisited[0]=true;
        for (int i = 0; i < getNumOfVertex(); i++) {
    
    
            bfs(isVisited,i);
        }
    }
    /**
     * 返回结点的个数
     * @return
     */
    public int getNumOfVertex(){
    
    
        return vertexList.size();
    }
    /**
     * 返回边的条个数
     * @return
     */
    public int getNumOfEdge(){
    
    
        return numOfEdge;
    }
    /**
     * 返回结点i(下标)对应的数据0->"A" 1->"B" 2->"C"
     * @return
     */
    public String getValueByIndex(int i){
    
    
        return vertexList.get(i);
    }

    /**
     * 显示图对应的矩阵
     */
    public void showGraph(){
    
    
        for (int[] edge : edges) {
    
    
            for (int i : edge) {
    
    
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
    /**
     * 返回坐标对应的权值
     * @param v1
     * @param v2
     * @return
     */
    public int getWeight(int v1,int v2){
    
    
        return edges[v1][v2];
    }
    /**
     * 插入结点
     * @param vertex
     */
    public void insertVertex(String vertex){
    
    
        vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 表示第一个点的下标
     * @param v2 表示第二个点的下标
     *           比如：A对应v1且值为0,B对应v2且值为1
     * @param weight
     */
    public void insertEdge(int v1,int v2,int weight){
    
    
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdge++;
    }
}

五、图的深度优先 VS 广度优先

5.1、深度优先测试：

public static void main(String[] args) {
    
    
        //测试一把图是否创建成功
        int n=8;//结点的个数
        String vertexValue[]={
    
    "1","2","3","4","5","6","7","8"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String  value:vertexValue){
    
    
            graph.insertVertex(value);
        }
        //添加边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);


        //显示邻接矩阵
        graph.showGraph();

        //dfs遍历
        System.out.print("深度遍历：");
        graph.dfs(graph.isVisited,0);
    }

打印结果：
深度遍历：1->2->4->8->5->3->6->7->

5.2、广度优先测试：

public static void main(String[] args) {
    
    
        //测试一把图是否创建成功
        int n=8;//结点的个数
        String vertexValue[]={
    
    "1","2","3","4","5","6","7","8"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String  value:vertexValue){
    
    
            graph.insertVertex(value);
        }
        //添加边
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);

        //显示邻接矩阵
        graph.showGraph();

        System.out.print("广度优先：");
        graph.bfs();
    }

打印结果：
广度优先：1=>2=>3=>4=>5=>6=>7=>8=>