7.图

图

1.基本概念

有权图、无权图；有向图、无向图

表示方式：邻接矩阵、邻接表

public class Graph {
    //n个顶点的图的储存
    private ArrayList<String> vList;
    private int[][] edges;
    private int numOfEdges;
​
    public Graph(int n) {
        edges = new int[n][n];
        vList = new ArrayList<>(n);
    }
    //插入节点
    public void insertV(String v){
        vList.add(v);
    }
    //添加无向边
    public void insertE(int v1,int v2,int weight){
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}
​

2.遍历

2.1 DFS深度优先

public void dfs(){
    //返回条件
    if(){}
    //下一步
    dfs();
}
//以及标记访问节点
//可用栈实现

 

2.2 BFS广度优先

//队列实现
//如 树的层序遍历
public void bfs(){
    //
    Queue<Node> queue;
    //加入首节点
    queue.offer(first);
    while(!queue.isEmpty()){
        //处理当前队首
        //记录步数或标记节点
        //加入下一层的新节点       
    }
}

 

3.最短路径

3.1 Dijkstra算法

从一个点到其他点的最短距离及路径

class Mgraph {
    private char[] vertex;//顶点数组
    private int[][] matrix;//邻接矩阵
    private VisitedVertex vv;
​
    public Mgraph(char[] vertex, int[][] matrix) {
        this.vertex = vertex;
        this.matrix = matrix;
    }
​
    public void showGraph() {
        for (int[] ints : matrix) {
            System.out.println(Arrays.toString(ints));
        }
    }
​
    //实现
    public void dsj(int index) {
        vv = new VisitedVertex(vertex.length, index);
        update(index);
        for (int j = 1; j < vertex.length; j++) {
            index = vv.updateArr();//下一个点
            update(index);
        }
    }
​
    //更新index点到周围点的距离和周围顶点的前驱
    private void update(int index) {
        int len = 0;
        //index 的周围点
        for (int i = 0; i < matrix[index].length; i++) {
            len = vv.getDis(index) + matrix[index][i];//出发点到index的最短距离加index到j的距离
            if (vv.in(i) && len < vv.getDis(i)) {//更新
                vv.updateDis(i, len);
                vv.updatePre(i, index);
            }
        }
    }
}
​
class VisitedVertex {
    public int[] visited;//是否访问过
    public int[] pre;//记录前驱
    public int[] dis;//记录由起点到 i 的最短距离
​
    public VisitedVertex(int len, int index) {
        this.visited = new int[len];
        this.pre = new int[len];
        this.dis = new int[len];
        //初始化最短距离数组，先设为不可达
        Arrays.fill(dis, Integer.MAX_VALUE);
        this.dis[index] = 0;//出发点到自己为0
        this.visited[index] = 1;
    }
​
    //判断是否访问过
    public boolean in(int index) {
        return visited[index] == 1;
    }
​
    //更新最短距离
    public void updateDis(int index, int len) {
        dis[index] = len;
    }
​
    //更新 p 的前驱为 index
    public void updatePre(int p, int index) {
        pre[p] = index;
    }
​
    //返回当前最短距离
    public int getDis(int index) {
        return dis[index];
    }
​
    //找出当前能访问的最近点index
    public int updateArr(){
        int min = Integer.MAX_VALUE,index = 0;
        for(int i = 0;i < visited.length;i++){
            if(visited[i]==0 && dis[i]<min){
                min = dis[i];
                index = i;
            }
        }
        visited[index] =1;
        return index;
    }
}

3.2 Floyd算法

求出每个顶点到其他顶点的最短路径

class Fgraph{
    private char[] vertex;//顶点
    private int[][] dis;//最短
    private int[][] pre;//前驱
​
    public Fgraph(int length,int[][] matrix,char[] vertex) {
        this.vertex = vertex;
        this.dis = matrix;
        this.pre = new int[length][length];
        //初始化
        for (int i = 0; i < length; i++) {
            Arrays.fill(pre[i],i);
        }
    }
    public void floyd(){
        int len = 0;
​
        //k为中间顶点
        for (int k = 0; k < dis.length; k++) {
            //从i顶点开始出发
            for (int i = 0; i < dis.length; i++) {
                for (int j = 0; j < dis.length; j++) {
                    //从i经过k到j的距离
                    len = dis[i][k] + dis[k][j];
                    if(len<dis[i][j]){
                        dis[i][j]=len;//更新距离
                        pre[i][j] = pre[k][j];//更新前驱
                    }
                }
            }
        }
    }
​
}