（十六）图的基本操作---两种遍历

于 2021-06-03 11:19:12 发布
阅读量329 收藏 2
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Apikaqiu/article/details/117510125
版权

图（存储结构）

1.邻接矩阵–数组表示法

邻接矩阵是表示图形中顶点之间相邻关系的矩阵，可以使用两个数组分别存储数据元素（顶点）的信息和数据元素之间的关系（边或弧）的信息
在这里插入图片描述

2.邻接表–链表

邻接表是图的一种链式存储结构。在邻接表中，对图中的每个顶点建立一个单链表，第i个单链表中的结点表示依附于顶点vi的边（对有向图是以顶点vi为尾的弧）。
在这里插入图片描述

构建图（数组）

在这里插入图片描述

package com.atguigu.graph;

import java.util.ArrayList;
import java.util.Arrays;

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 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();
    }

    //构造器
    public Graph(int n){
        //初始化矩阵和vertexList
        edges=new int[n][n];
        vertexList=new ArrayList<>(n);
        numOfEdges=0;
    }

    //返回结点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }

    //返回结点i(下标)对应的数据  0-->"A"   1-->"B"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回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));
        }
    }

    //插入结点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边

    /**
     *
     * @param v1 表示点的下标，即第几个顶点 "A"-"B"  "A"-->0  "B"-->1
     * @param v2
     * @param weight
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdges++;

    }
}

深度优先

基本思想

  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。
    在这里插入图片描述
package com.atguigu.graph;

import java.util.ArrayList;
import java.util.Arrays;

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 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();
        
        //dfs遍历
        System.out.println("深度遍历");
        graph.dfs();

    }

    //构造器
    public Graph(int n){
        //初始化矩阵和vertexList
        edges=new int[n][n];
        vertexList=new ArrayList<>(n);
        numOfEdges=0;
        isVisited=new boolean[5];
    }

    //得到第一个邻接结点的下标w
    /**
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-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.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重载
    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(下标)对应的数据  0-->"A"   1-->"B"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回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));
        }
    }

    //插入结点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边

    /**
     *
     * @param v1 表示点的下标，即第几个顶点 "A"-"B"  "A"-->0  "B"-->1
     * @param v2
     * @param weight
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdges++;

    }
}

广度优先

基本思想

  1. 图的广度优先搜索(Broad First Search) 。
  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。

在这里插入图片描述

package com.atguigu.graph;

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

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 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();

 

        //bfs遍历
        System.out.println("广度优先遍历");
        graph.bfs();

    }

    //构造器
    public Graph(int n){
        //初始化矩阵和vertexList
        edges=new int[n][n];
        vertexList=new ArrayList<>(n);
        numOfEdges=0;
        isVisited=new boolean[5];
    }

    //得到第一个邻接结点的下标w
    /**
     *
     * @param index
     * @return 如果存在就返回对应的下标，否则返回-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 bfs(boolean[] isVisited,int i){
        int u;//表示队列的头结点对应的下标
        int w;//邻接结点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){
                //是否访问过
                if (!isVisited[w]){
                    System.out.print(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(下标)对应的数据  0-->"A"   1-->"B"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }

    //返回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));
        }
    }

    //插入结点
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    //添加边

    /**
     *
     * @param v1 表示点的下标，即第几个顶点 "A"-"B"  "A"-->0  "B"-->1
     * @param v2
     * @param weight
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
        numOfEdges++;

    }
}
顺毛黑起
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值