数据结构与算法-图结构 | 尚硅谷韩顺平

最新推荐文章于 2024-10-01 22:30:45 发布

卒获有所闻

最新推荐文章于 2024-10-01 22:30:45 发布

阅读量419

点赞数 2

分类专栏：数据结构与算法文章标签：数据结构图搜索广度优先深度优先

本文链接：https://blog.csdn.net/weixin_54232666/article/details/127171989

版权

数据结构与算法专栏收录该内容

14 篇文章 3 订阅

订阅专栏

一、图的概述

1、图的基本介绍

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

2、图的存储方式

（1）二维数组表示（邻接矩阵）

可以连通的用1表示，不能连通的用0表示

（2）链表表示（邻接表）

邻接表的实现只关心存在的边，不存在的不表示，因此没有空间浪费，是由数组+链表组成

二、快速入门案例

代码实现

public class Graph {
    private ArrayList<String> vertexList; //存储顶点的集合
    private int[][] edges;//存储图的邻接矩阵
    private int numOfEdges; //表示边的数目

    public static void main(String[] args) {
        int n=5;
        String VertexValue[] = {"A","B","C","D","E"};
        //创建图对象
        Graph graph = new Graph(n);
        for (String vertex:VertexValue){
            graph.insertVertex(vertex);
        }
        //添加边
        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();
    }
    //构造器
    public Graph(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
    }
    //返回节点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }
    //插入顶点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }
    //返回v1和v2的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
    //显示图对应的矩阵
    public void showGraph(){
        for (int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }
    //添加边
    //v1表示第一个顶点下标 v2表示第二个顶点下标 weight0还是1
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

三、图的遍历

图的遍历，就是对节点的访问。主要分为深度优先遍历和广度优先遍历

1、深度优先遍历DFS

基本思想

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

算法步骤

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

代码实现

public class Graph {
    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"};
        //创建图对象
        Graph graph = new Graph(n);
        for (String vertex:VertexValue){
            graph.insertVertex(vertex);
        }
        //添加边
        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.dfs();
    }
    //构造器
    public Graph(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
        isVisited = new boolean[5];
    }

    //得到第一个邻接节点的下标
    //存在返回对应下标 不存在返回-1
    public int getFirstNeighbor(int index){
        for (int j = 0;j<vertexList.size();j++){
            if (edges[index][j]>0){
                return j;
            }
        }
        return -1;
    }
    //根据前一个邻接结点的下标来获取下一个邻接节点
    public int getNextNeighbor(int v1,int v2){
        for (int j=v2+1;j<vertexList.size();j++){
            if (edges[v1][j]>0){
                return j;
            }
        }
        return -1;
    }
    //深度优先遍历算法
    private void dfs(boolean[] isVisited,int i){
        //首先我们访问该节点，输出
        System.out.println(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);
            }
        }
    }

    //返回节点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }
    //插入顶点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }
    //返回v1和v2的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
    //显示图对应的矩阵
    public void showGraph(){
        for (int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }
    //添加边
    //v1表示第一个顶点下标 v2表示第二个顶点下标 weight0还是1
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

2、广度优先遍历BFS

基本思想

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

算法步骤

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

代码实现

public class Graph {
    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"};
        //创建图对象
        Graph graph = new Graph(n);
        for (String vertex:VertexValue){
            graph.insertVertex(vertex);
        }
        //添加边
        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.dfs();

        System.out.println("广度优先");
        graph.bfs();
    }
    //构造器
    public Graph(int n) {
        edges = new int[n][n];
        vertexList = new ArrayList<String>(n);
        numOfEdges = 0;
        isVisited = new boolean[5];
    }

    //得到第一个邻接节点的下标
    //存在返回对应下标 不存在返回-1
    public int getFirstNeighbor(int index){
        for (int j = 0;j<vertexList.size();j++){
            if (edges[index][j]>0){
                return j;
            }
        }
        return -1;
    }
    //根据前一个邻接结点的下标来获取下一个邻接节点
    public int getNextNeighbor(int v1,int v2){
        for (int j=v2+1;j<vertexList.size();j++){
            if (edges[v1][j]>0){
                return j;
            }
        }
        return -1;
    }
    //深度优先遍历算法
    private void dfs(boolean[] isVisited,int i){
        //首先我们访问该节点，输出
        System.out.println(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);
            }
        }
    }

    //对一个节点进行广度优先遍历
    private void bfs(boolean[] isVisited,int i){
        int u; //表示头结点的下标
        int w; //邻接点的下标
        //队列，记录节点访问的顺序
        LinkedList queue = new LinkedList();
        //访问节点
        System.out.println(getValueByIndex(i)+"=>");
        //标记为已经访问
        isVisited[i]=true;
        //将节点加入队列
        queue.addLast(i);
        while (!queue.isEmpty()){
            //取出队列头
            u = (Integer)queue.removeFirst();
            //得到第一个邻节点的下标w
            w=getFirstNeighbor(u);
            while (w!=-1){
                //是否访问过
                if (!isVisited[w]){
                    System.out.println(getValueByIndex(w)+"=>");
                    //标记已经访问
                    isVisited[w]=true;
                    //入队列
                    queue.addLast(w);
                }
                //以u为前驱点找w后面的下一个邻接点
                w = getNextNeighbor(u,w);//体现广度优先
            }
        }
    }
    //遍历所有的节点进行广度
    public void bfs(){
        for (int i = 0;i<getNumOfVertex();i++){
            if (!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }


    //返回节点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点i对应的数据
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }
    //插入顶点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }
    //返回v1和v2的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
    //显示图对应的矩阵
    public void showGraph(){
        for (int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }
    //添加边
    //v1表示第一个顶点下标 v2表示第二个顶点下标 weight0还是1
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}