用Java数组【邻接矩阵】实现【图】的入门

本文完整代码下载

一、基本介绍

1.为什么要有图

1. 线性表局限于一个直接前驱和一个直接后继的关系
2. 树也只能有一个直接前驱也就是父节点
3. 当我们需要表示多对多的关系时， 这里我们就用到了图

2.基本术语

• 图是一种数据结构，其中结点可以具有零个或多个相邻元素。
• 两个结点之间的连接称为边(edge)。
• 结点也可以称为顶点(vertex)。
• 路径：如下图，从A →B→C 就是一条路径
• 无向图：如下图，没有每个顶点之间没有指向的图
  
• 有向图：
  
• 带权图
  

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

3.邻接矩阵

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

4.邻接表

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

二、创建图(graph)

将下图用邻接矩阵保存

思路分析

1. 存储顶点。
2. 保存矩阵。

代码实现

class Graph {
    /**存储顶点集合*/
    private ArrayList<String> vertexList;
    /**存储图对应的邻接矩阵*/
    private int[][] edges;
    /**总边数*/
    private int numOfEdges;
    /**某个结点是否被访问过*/
    private boolean[] isVisited;

    /**
     * 构造器，进行初始化
     */
    public Graph(int vertexSize) {
        edges = new int[vertexSize][vertexSize];
        vertexList = new ArrayList<>(vertexSize);
        isVisited = new boolean[vertexSize];
    }
    /**
     * 添加顶点/结点
     */
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }

    /**
     * 添加边
     * @param v1 第一个顶点的下标
     * @param v2 第二个顶点的下标
     * @param weight 权值
     */
    public void insertEdge(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
 	/**
     * 显示图的对应矩阵
     */
    public void showGraph(){
        for (int[] link : edges){
            System.out.println(Arrays.toString(link));
        }
    }
}

运行效果

三、深度优先遍历

介绍

图的深度优先搜索(Depth First Search) 。

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。

代码实现

所需调用基础方法

class Graph {
	/**
     * 得到第一个临接结点的下标
     *
     * @param index 第几个结点
     * @return 存在则返回下标，否则返回-1
     */
    private int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if(edges[index][j] > 0){
                return j;
            }
        }
        return -1;
    }

    /**
     * 根据前一个邻接结点的下标来获取从下一个邻接结点
     * @param v1 要查找的结点的下标
     * @param v2 开始的下标
     * @return 存在则返回下标，否则返回-1
     */
    private int getNextNeighbor(int v1, int v2){
        for(int j = v2 + 1; j < vertexList.size(); j ++){
            if(edges[v1][j] > 0){
                return j;
            }
        }
        return -1;
    }

    /**
     * 返回结点个数
     * @return 结点个数
     */
    private int getNumOfVertex(){
        return vertexList.size();
    }

    /**
     * 边的数量
     * @return 边的数量
     */
    private int getNumOfEdges(){
        return numOfEdges;
    }

    /**
     * 获取结点i(下标)的值
     * @param i
     * @return
     */
    private String getValueByIndex(int i){
        return vertexList.get(i);
    }

    /**
     * 返回v1 和 v2 的权值
     * @param v1
     * @param v2
     * @return
     */
    private int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
}

深度优先遍历算法代码

class Graph {
	/**
     * 深度优先遍历算法
     * @param i
     */
    private void depthFirstSearch(int i){
        //输出当前结点
        System.out.print(getValueByIndex(i)+" -> ");
        //将结点设置为已访问
        isVisited[i] = true;
        //查找结点i 的第一个邻接结点 w
        int w = getFirstNeighbor(i);
        while (w != -1){
            if(!isVisited[w]){
                depthFirstSearch(w);
            }
            w = getNextNeighbor(i,w);
        }
    }

    /**
     * 暴露出方法深度优先遍历算法
     */
    public void depthFirstSearch(){
        clearIsVisited();
        //遍历所有节点
        for (int i = 0; i < getNumOfVertex(); i++) {
            if(!isVisited[i]){
                depthFirstSearch(i);
            }
        }
        System.out.println();
    }
}

四、广度优先遍历

介绍

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

遍历步骤

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。

代码实现

class Graph {
	/**
     * 广度优先算法
     * @param i
     */
    private void breadthFirstSearch(int i){
        //队列头结点的下标
        int headIndex;
        //邻接节点
        int neighborIndex;
        //记录节点访问的顺序
        LinkedList queue = new LinkedList();
        //输出结点信息
        System.out.print(getValueByIndex(i) + " -> ");
        //标记已访问
        isVisited[i] = true;
        //将结点加入队列
        queue.addLast(i);

        while(!queue.isEmpty()){
            //取出队列的头结点下标
            headIndex = (Integer)queue.removeFirst();
            //得到第一个邻接结点的下标
            neighborIndex = getFirstNeighbor(headIndex);
            //不断进入下一层
            while (neighborIndex != -1){
                //判断是否访问过
                if(!isVisited[neighborIndex]){
                    System.out.print(getValueByIndex(neighborIndex) + " -> " );
                    //标记已访问
                    isVisited[neighborIndex] = true;
                    //将结点加入队列
                    queue.addLast(neighborIndex);
                }
                neighborIndex = getNextNeighbor(headIndex,neighborIndex);
            }
        }
    }

    /**
     * 暴露出方法广度优先遍历算法
     */
    public void breadthFirstSearch(){
        clearIsVisited();
        for (int i = 0;i < getNumOfVertex();i++){
            if(!isVisited[i]){
                breadthFirstSearch(i);
            }
        }
        System.out.println();
    }
}

运行效果

本文完整代码下载