高龄白菜java学习第103天（java数据结构和算法（21））

第七章：图

一、图的创建

思路分析
1、用一个String数组保存顶点
2、用一个二维数组保存邻接矩阵
3、通过方法实现顶点之间边的添加和计数

package Graph;

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

//图
public class Graph {

    private ArrayList<String> vertexList;//存储顶点
    private int[][] edges;//存储边
    private int numsEdges;//边的数目

    public Graph(int n) {//在构造器中实现初始化
        vertexList = new ArrayList<>(n);
        edges = new int[n][n];
        numsEdges = 0;
    }


    //添加顶点
    public void add(String vertex){
        vertexList.add(vertex);
    }

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

    /**
     * 功能：添加边
     * @param v1    第一个顶点（点的下标）
     * @param v2    第二个顶点
     * @param weight    权值，0代表不直接相连，1与之相反
     */
    public void insertEdge(int v1, int v2, int weight){
        edges[v1][v2] =weight;
        edges[v2][v1] =weight;
        numsEdges++;
    }

    //返回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 static void main(String[] args) {
        int n =5;
        String[] vertexValue = {"A","B","C","D","E"};
        Graph graph = new Graph(n);
        for (String s : vertexValue) {
            graph.add(s);
        }
        graph.insertEdge(2,4,1);
        graph.showGraph();
    }
}

二、深度优先遍历

三、广度优先遍历

深度遍历+广度遍历代码实现

package Graph;

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

//图
public class Graph {

    public static void main(String[] args) {
        int n = 5;
        String[] vertexValue = {"A", "B", "C", "D", "E"};
        Graph graph = new Graph(n);
        for (String s : vertexValue) {
            graph.add(s);
        }
        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();

//        graph.dfs();
        graph.bfs();
    }

    private ArrayList<String> vertexList;//存储顶点
    private int[][] edges;//存储边
    private int numsEdges;//边的数目
    private boolean[] isVisited;//标识节点是否已经被访问


    public Graph(int n) {//在构造器中实现初始化
        vertexList = new ArrayList<>(n);
        edges = new int[n][n];
        numsEdges = 0;
        isVisited = new boolean[n];
    }


    //添加顶点
    public void add(String vertex) {
        vertexList.add(vertex);
    }

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

    /**
     * 功能：添加边
     *
     * @param v1     第一个顶点（点的下标）
     * @param v2     第二个顶点
     * @param weight 权值，0代表不直接相连，1与之相反
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numsEdges++;
    }

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

    //获取第一个邻接节点的下标w
    public int getFirstNode(int index) {
        for (int j = 0; j < vertexList.size(); j++) {
            if (edges[index][j] != 0) {
                return j;
            }
        }
        return -1;
    }

    //根据前一个邻接节点的下标来获取第二个邻接节点的下标
    //v1、v2：前一个邻接节点(指糖葫芦里的第二个)的行下标和列下标
    public int getNextNode(int v1, int v2) {
        for (int j = v2 + 1; j < vertexList.size(); j++) {
            if (edges[v1][j] != 0) {
                return j;
            }
        }
        return -1;
    }

    //深度优先算法
    public void dfs(boolean[] isVisited, int i) {
        //输出当前节点
        System.out.println(vertexList.get(i));
        //将节点设置为已访问
        isVisited[i] = true;
        //查找结点i的第一个邻接节点w的下标
        int w = getFirstNode(i);
        while (w != -1) {//说明有邻接节点
            if (!isVisited[w]) {
                dfs(isVisited, w);
            }
            //如果已经被访问过
            w = getNextNode(i, w);
        }
    }

    //重载dfs，遍历我们所有的节点（避免有和其他节点不相连的单独节点==>非连通图）
    public void dfs() {
        for (int i = 0; i < getSize(); i++) {
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    //广度优先算法
    public void bfs(boolean[] isVisited, int i) {
        int u;//队列中头节点对应的下标
        int w;//邻接点对应的下标
        LinkedList<Object> queue = new LinkedList<>();//队列，记录访问节点的先后顺序
        System.out.println(vertexList.get(i));
        isVisited[i] = true;
        //将节点加入队列
        queue.addLast(i);
        while (!queue.isEmpty()) {
            //取出队列的头节点下标
            u = (Integer) queue.removeFirst();
            w = getFirstNode(u);
            while (w != -1) {//将当前节点所有未访问过的邻接节点获取到并入队
                if (!isVisited[w]) {
                    System.out.println(vertexList.get(w));
                    isVisited[w] = true;
                    queue.addLast(w);
                }
                w = getNextNode(i, w);
            }
        }
    }

    //针对非连通图
    public void bfs() {
        for (int i = 0; i < getSize(); i++) {
            if (!isVisited[i]) {
                bfs(isVisited, i);
            }
        }
    }
}