数据结构-图

一、为什么要有图

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

二、图的概念

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

三、图的表示方式

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

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

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

上图说明
1）标号为0的结点的相关联的结点为1 2 3 4
2）标号为1的结点的相关联结点为0 4，
3）标号为2的结点相关联的结点为0 4 5
4）....

四、简单案例

要求：代码实现如下图的结构

• 思路分析

图的邻接矩阵表示可以通过二维数组来实现，其中数组的索引代表图中顶点的位置，数组的元素表示顶点之间的连接关系（例如，权重或者是否存在连接）。

创建了一个Graph类来表示图，它包含一个vertices变量来存储图中的顶点数量，以及一个二维数组adjMatrix来存储邻接矩阵。addEdge方法用于添加边，并同时设置两个方向的连接（因为是无向图）。printGraph方法用于打印邻接矩阵，这里为了演示，我们使用"INF "来表示两个顶点之间没有直接的连接（当然，也可以选择使用空格或其他方式来表示）。

• 代码实现

public class Graph {  
    // 顶点数量  
    private int vertices;  
    // 邻接矩阵，使用int[][]表示，初始化为无穷大或0（表示无连接）  
    // 这里使用0表示无连接，假设权重是整数  
    private int[][] adjMatrix;  
  
    // 构造函数  
    public Graph(int vertices) {  
        this.vertices = vertices;  
        // 初始化邻接矩阵，大小为vertices x vertices，所有元素初始化为0  
        adjMatrix = new int[vertices][vertices];  
    }  
  
    // 添加边  
    // 注意：无向图中，添加一条边意味着两个方向都要设置  
    public void addEdge(int v1, int v2, int weight) {  
        // 检查顶点有效性  
        if (v1 >= vertices || v2 >= vertices || v1 < 0 || v2 < 0) {  
            System.out.println("Invalid vertex!");  
            return;  
        }  
        // 由于是无向图，所以两个方向都要设置  
        adjMatrix[v1][v2] = weight;  
        adjMatrix[v2][v1] = weight;  
    }  
  
    // 打印邻接矩阵  
    public void printGraph() {  
        for (int i = 0; i < vertices; i++) {  
            for (int j = 0; j < vertices; j++) {  
                if (adjMatrix[i][j] == 0)  
                    System.out.print("INF "); // 或者使用" "表示无连接  
                else  
                    System.out.print(adjMatrix[i][j] + " ");  
            }  
            System.out.println();  
        }  
    }  
  
    // 测试代码  
    public static void main(String[] args) {  
        Graph g = new Graph(4);  
  
        g.addEdge(0, 1, 1);  
        g.addEdge(0, 2, 5);  
        g.addEdge(1, 2, 3);  
        g.addEdge(2, 3, 1);  
        g.addEdge(3, 1, 4);  
  
        g.printGraph();  
    }  
}

五、图的深度优先搜索(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。

使用递归实现深度优先遍历

import java.util.*; 
 
public class Graph {
    private int V; // 顶点的数量 
    private List> adj; // 邻接表 
 
    // 构造函数 
    public Graph(int v) {
        V = v;
        adj = new ArrayList<>(v);
        for (int i = 0; i < v; i++) {
            adj.add(new  ArrayList<>());
        }
    }
 
    // 添加边 
    public void addEdge(int v, int w) {
        adj.get(v).add(w); 
    }
 
    // DFS 递归实现 
    public void DFS(int v, boolean[] visited) {
        visited[v] = true;
        System.out.print(v  + " ");
 
        List children = adj.get(v); 
        for (Integer c : children) {
            if (!visited[c]) {
                DFS(c, visited);
            }
        }
    }
 
    // DFS 遍历整个图 
    public void DFSUtil() {
        boolean[] visited = new boolean[V];
        for (int i = 0; i < V; i++) {
            if (!visited[i]) {
                DFS(i, visited);
            }
        }
    }
 
    public static void main(String[] args) {
        Graph g = new Graph(4);
        g.addEdge(0,  1);
        g.addEdge(0,  2);
        g.addEdge(1,  2);
        g.addEdge(2,  0);
        g.addEdge(2,  3);
        g.addEdge(3,  3);
 
        System.out.println("Depth  First Traversal (starting from vertex 2):");
        g.DFSUtil();
    }
}

使用栈实现深度优先遍历

import java.util.*; 
 
public class GraphWithStack {
    private int V; // 顶点的数量 
    private List> adj; // 邻接表 
 
    public GraphWithStack(int v) {
        V = v;
        adj = new ArrayList<>(v);
        for (int i = 0; i < v; i++) {
            adj.add(new  ArrayList<>());
        }
    }
 
    public void addEdge(int v, int w) {
        adj.get(v).add(w); 
    }
 
    // 使用栈实现DFS 
    public void DFSWithStack(int start) {
        Stack stack = new Stack<>();
        boolean[] visited = new boolean[V];
 
        stack.push(start); 
        visited[start] = true;
 
        while (!stack.isEmpty())  {
            int v = stack.pop(); 
            System.out.print(v  + " ");
 
            List children = adj.get(v); 
            for (int i = children.size()  - 1; i >= 0; i--) { // 逆序访问 
                int c = children.get(i); 
                if (!visited[c]) {
                    visited[c] = true;
                    stack.push(c); 
                }
            }
        }
    }
 
    public static void main(String[] args) {
        GraphWithStack g = new GraphWithStack(4);
        g.addEdge(0,  1);
        g.addEdge(0,  2);
        g.addEdge(1,  2);
        g.addEdge(2,  0);
        g.addEdge(2,  3);
        g.addEdge(3,  3);
 
        System.out.println("Depth  First Traversal using Stack:");
        g.DFSWithStack(2); // 开始遍历的顶点为2 
    }
}