【数据结构】---图

图

前言

本篇作为图的基础概念篇，了解图的离散数学定义，图的分类，图模型解决的问题（图的应用），图的相关算法（仅仅介绍，具体不在此篇展开）。

学习基本路线：

学习离散数学的图章节。对图有宏观的把握。
从代码上，完成图的表示。学习深度优先搜索和广度优先搜索。
进一步学习图的其它算法，比如单源最短路径，求解图的连通分量，最小生成树算法等等，还可以求解离散数学的其它问题（如二分图，欧拉图，哈密顿图等等）。学习图的算法可以加深对离散数学在计算机科学的理解。

离散数学这门学科本身就广泛应用于各大学科，并非只是对计算机科学如此。

引入

图是由顶点和连接顶点的边构成的离散结构。
根据图中的边是否有方向？相同顶点对之间是否有多条边相连以及是否允许存在自环
图的定义
$G = (V, E)$ 由顶点（或结点）的非空集 $V$ 和边集 $E$ 构成，每条边有一个或两个顶点与它相连，这样的顶点与它相连，该顶点称为边的端点。边连接它的端点。
$V - > v er t e x$ ：图中的元素,顶点或者结点。
$E - > e d g e$ ：连接一个或者两个端点。
$Edge\subseteq V\times V$ :描述了是边的顶点的二元集.
$∣ E ∣$ :边的条数.
$∣ V ∣$ :顶点个数.
考虑有限图:顶点集和边集为有限集的图称为有限图。

重点-简单图:

"No self loops": 图中的顶点不能有连接到自身的边,不能有自环的情况.
"Every edge is distinct": 不能存在相同的边.
针对无向图:每对顶点只有一条边.
针对有向图:每对顶点同方向的边唯一.
不重点考虑多重图，即存在不同边连接一对相同的顶点。
不考虑自环现象：即，边关联的两个顶点是同一个顶点。
图的分类
有向图与无向图.

对 $v, u$
无向图:边被描述为顶点的无序二元集:{v,u},说明了 $v$ , $u$ 两顶点之间有一条边.无序性:含义是 {u,v} $=$ {v,u} .
有向图:边被表示为顶点的有序二元集:(v,u),说明了 $v$ , $u$ 有一条顶点v到u的边.有序性:含义是 (u,v) 和 (v,u) 是两条不同的边
无向图的边是无序的二元对，而有向图的边是有序的二元对。

有向图

定义: 有向图 $G = (V, E)$ ，由一个非空顶点集 $V$ 和一个有向边（称为弧）集 $E$ 组成。每条有向边与一个有序点对相关联。有序对 $(u, v)$ 相关联的有向边开始于 $u$ 、结束于 $v$ 。
简单有向图：简单图的基础上赋予方向就是简单有向图。

其它图的讨论

混合图：既包含有向边和无向边的图称为无向图。
实际写代码时，混合图和无向图均可以当作有向图，无向边当作两条对立的有向边。

多重图：即允许两顶点之间存在多条边的图。
自环：自环是指一条边的起点和终点是同一个节点。

图的术语和特殊类型的图

图的基本术语

图 (Graph): 由顶点 (Vertices) 和边 (Edges) 组成的数学结构，用于表示对象之间的关系。
顶点 (Vertex): 图中的基本单位，通常表示一个对象。
边 (Edge): 连接两个顶点的线，表示它们之间的关系。
邻接 (Adjacent): 如果两个顶点之间有边相连，则称它们是邻接的。若两顶点 $u$ 和 $v$ 是无向图 $G$ 中的一条边 $e$ 的端点，则称两个顶点 $u$ 和 $v$ $G$ 里邻接（相邻）。称边 $e$ 为关联顶点 $u, v$ 。或者叫做边 $e$ 连接 $u$ $, v$ 。对于有向图，假设是 $u$ 到 $v$ 的有向边，那么称边e把 $u$ 邻接到 $v$ ，或者称 $v$ 从 $u$ 邻接。简而言之，对于这条有向边，只能说u邻接v,而v不邻接u。
路径 (Path): 从一个顶点到另一个顶点的边的序列，且没有重复的顶点。
圈 (Cycle): 从一个顶点出发，经过若干边后回到该顶点的路径，且路径中的其他顶点都不重复。
度：
顶点的度(degree):跟顶点相连接的边的条数。
入度与出度:对于有向图，一个顶点的入度是指以其为终点的边数；
出度指以该顶点为起点的边数。反应了度和边数的关系。
图的度:
对于无向图 $\forall v\in V, \sum degree(v) = 2|E|$
对于有向图 $\forall v\in V, \sum degree^+(v) = \sum degree^-(v)= |E|$
$degree^+(v):有向图顶点的出度.$ $degree^-(v)：$ 有向图顶点的入度。
顶点度为0的点是孤立点
顶点度为1的点是悬挂点

特殊类型的图汇总

无向图 (Undirected Graph): 边没有方向，连接的两个顶点是对称的。
有向图 (Directed Graph): 边有方向，表示从一个顶点到另一个顶点的单向关系。
加权图 (Weighted Graph): 每条边都有一个权重，表示边的成本、距离等。
简单图 (Simple Graph): 不允许有自环（从一个顶点到自身的边）和多重边（相同的两个顶点之间有多条边）。
完全图 (Complete Graph): 图中每一对顶点之间都有边相连。
树 (Tree): 一种特殊的无向图，具有无圈的特性，且任何两个顶点之间都有唯一的路径。
森林 (Forest): 由多个树组成的图。
连通图 (Connected Graph): 在无向图中，任意两个顶点之间都存在路径；在有向图中，存在从一个顶点到另一个顶点的有向路径。
强连通图 (Strongly Connected Graph): 在有向图中，任意两个顶点之间都有有向路径。
平面图 (Planar Graph): 可以在平面上绘制的图，使得边的交叉最小。

关于连通图，可达性，路径等概念，结合后续算法题说明。

图的基本术语

顶点相邻：若两顶点 $u$ 和 $v$ 是无向图 $G$ 中的一条边 $e$ 的端点，则称两个顶点 $u$ 和 $v$ $G$ 里邻接（相邻）。称边 $e$ 为关联顶点 $u, v$ 。或者叫做边 $e$ 连接 $u$ $, v$ 。
邻居: $G = (V, E)$ ,顶点 $v$ 的所有相邻顶点的集合，记作 $N (v)$ 。其称为顶点的邻居。
度：
顶点的度(degree):跟顶点相连接的边的条数。
入度与出度:对于有向图，一个顶点的入度是指以其为终点的边数；
出度指以该顶点为起点的边数。反应了度和边数的关系。
图的度:
对于无向图 $\forall v\in V, \sum degree(v) = 2|E|$
对于有向图 $\forall v\in V, \sum degree^+(v) = \sum degree^-(v)= |E|$
$degree^+(v):有向图顶点的出度.$ $degree^-(v)：$ 有向图顶点的入度。
顶点度为0的点是孤立点
顶点度为1的点是悬挂点

两个定理

握手定理：描述度与边数的关系。定义m图 $G$ — $\sum_{v\epsilon V}deg(V)$
无向图的有偶数个奇度顶点。

讨论简单图中无向图与有向图的边个数
无向图: $|E|\leq \begin{pmatrix} |V|\\ 2\\ \end{pmatrix}$
有向图: $|E|\leq2 \begin{pmatrix} |V|\\ 2\\ \end{pmatrix}$
解释:任取两顶点 $v, u$ 的排列数排列数 $2)=\frac{n\times(n-1)}{2}$ 。
这是最大值,因为可能并非所有两顶点都有边.
用大 $O$ 表示法: $\begin{pmatrix} |V|\\ 2\\ \end{pmatrix}=O(|V|^2)$

图的表示

关于图，标准的两种标准表示方法，一种表示将图作为邻接链表的组合，另一种将图作为邻接矩阵表示。
两种方法均可以表示无向图和有向图，更准确地可以表示混合图。

本篇实现偏向于邻接表，是图比较通用的写法。

图的个人通用实现

由前面图的定义，我们可以给出图的代码实现。
个人习惯用哈希表存储顶点和边，因为更符合数学上集合的概念。
其次，哈希表可以快速查询边或者顶点是否属于该图，且Java中的HashMap,HashSet存储的是不重复的元素，十分便利。

以下图适用于纯无向图，纯有向图，混合图，混合图，多重图，存在自环的图。
不过其仍旧是有限图，实际工程上也不存在无限图的情况。

前置准备

编程语言：Java
创建一个package graph,
创建三个.java文件，每个文件各有一个公共类，分别是Graph,Node,Edge。

Graph类

Graph,包含点集和边集。很符合数学中的定义，以下是基础版本的描述。

package Graph;  
  
import java.util.HashMap;  
import java.util.HashSet;  
  
public class Graph<V> {  
    /*将顶点按顺序编号 点集*/    
    public HashMap<Integer, Node<V>> nodes;  
    //存储边集  
    public HashSet<Edge<V>> edges;  
    //构造函数  
    public Graph() {  
        nodes = new HashMap<Integer, Node<V>>();  
        edges = new HashSet<Edge<V>>();  
    }  
}

public HashMap<Integer, Node<V>> nodes; 将顶点用整数编号，结合现实每座城市都有唯一标识的编号处理。

//判断图是否为空集  
public boolean isEmpty() {  
    return nodes.isEmpty();  
}  
//获取顶点数量  
public int size() {  
    return nodes.size();  
}  
//获取边的数量  
public int sizeOfEdges(){  
    return edges.size();  
}

尽管从数学角度上，图不为空集，但这里还是补上判空方法。

Node类，单个结点自带的值value, 入度和出度，邻接顶点，关联边数。
![[Pasted image 20240928194111.png]]

顶点存储自己的编号：后续对图的深拷贝有必要。
顶点可以存储附加值value。根据自己实际需求
顶点存储入度和出度的值：

入度: 指向某个节点的边的数量。它反映了有多少个其他节点指向该节点，揭示该节点在图中的“吸引力”或“重要性”。
出度:从某个节点发出的边的数量。它表明该节点能够连接多少其他节点，显示该节点的“影响力”或“传播能力”。
存储两者的信息可以反应该顶点的重要性，然后入度与出度这两个属性可以优化算法（比方说后续的最短路径，拓朴排序等等），它还可以反应图的结构特性，识别某个特定节点（孤立点，集群等等）。

顶点存储它直接可达的其它顶点（直接邻居）。

必要性：方便动态操作，比如我们要删去或者添加边时，只需要对相关顶点的邻接列表操作即可，避免了整体上所有邻接关系的修改。
快速访问邻居的信息。邻接列表相当于存储了直接邻居的地址，在后续处理遍历操作时异常便捷（深度优先遍历和广度优先遍历）。
很多算法依赖邻居关系，如最短路径，求解连通分量问题。
5. 存储以该节点为起点的有向边。高效访问节点附近的所有边；动态操作，操作边的增删查改时只需要局部性调整即可，非常便捷。维护信息，可以高效地维护其它属性。算法角度：对依赖边的图算法有较大的便利实现。

package Graph;    
    
import java.util.ArrayList;    
import java.util.Collections;    
import java.util.List;  
  
/**  
 * @author AutumnWhisper  
 * 回顾离散数学    
*/  
public class Node<V> {  
    int id;//编号    
	//顶点存储的值    
	V value;  
    //入度    
	int in;  
    //出度    
	int out;  
    //直接可达结点表:顶点V的所有相邻顶点的集合.====直接邻居    
	ArrayList<Node<V>> nexts;  
    //存储以该节点为起点的有向边。    
	ArrayList<Edge<V>> edges;  
  
    //初始化默认顶点为孤立点    
	public Node(int id,V value) {  
        this.id = id;  
        this.value = value;  
        this.in = 0;  
        this.out = 0;  
        this.nexts = new ArrayList<>();  
        this.edges = new ArrayList<>();  
    }  
    //获取当前顶点的编号  
	public int getId() {  
    return id;  
	}  
	//获取当前节点存储的有效值  
	public V getValue() {  
	    return value;  
	}  
	//设置当前节点存储的值  
	public V setValue(V value) {  
	    V oldVal = this.value;  
	    this.value = value;  
	    return oldVal;  
	}  
	//获取入度  
	public int getIn(){  
	    return in;  
	}  
	//获取出度  
	public int getOut(){  
	    return out;  
	}
    //提供当前顶点的邻接顶点列表（不可修改）    
	public List<Node<V>> getNexts(){  
        return Collections.unmodifiableList(nexts);  
    }  
    //提供以当前结点为顶点的关联边数。(不可修改)    
	public List<Edge<V>> getEdges(){  
        return Collections.unmodifiableList(edges);  
    }  
  
}

Node类提供两个辅助方法来新增邻居和边，这只是辅助其它方法实现的。

  
/**  
 * 当前节点新增邻居  
 * @param neighbor 邻居  
 */  
void addNeighbor(Node<V> neighbor){  
    nexts.add(neighbor);  
    this.out++;//当前节点出度+1  
    neighbor.in++;//邻居入度+1  
}  
  
/**  
 * 当前节点新增边  
 * @param edge 边  
 */  
void addEdge(Edge<V> edge){  
    edges.add(edge);  
}

Edge类
边附带的权重（有权图），边的方向（起点和终点）。

package Graph;  
  
//顶点不依赖边， 边依赖顶点  
public class Edge<V> {  
    //权重  
    int weight;  
    Node<V> from;//起点  
    Node<V> to;//终点  
    public Edge(int weight, Node<V> from, Node<V> to) {  
        this.weight = weight;  
        this.from = from;  
        this.to = to;  
    }  
    //----给包外提供的接口。  
    //获取权重  
    public int getWeight() {  
        return weight;  
    }  
    //重新设置权重  
    public void setWeight(int weight) {  
        this.weight = weight;  
    }  
    //获取边的起点  
    public Node<V> getFrom() {  
        return from;  
    }  
    //设置边的起点  
    public void setFrom(Node<V> from) {  
        this.from = from;  
    }  
    //获取边的终点  
    public Node<V> getTo() {  
        return to;  
    }  
    //设置边的终点  
    public void setTo(Node<V> to) {  
        this.to = to;  
    }  
}

基本操作

增加图中的边

通过图中增加一条边关联两个已有的顶点。
提取关键字：已有顶点，这意味着我们不能无中生有造边，而是依赖与图中现有的一对顶点。

假设我们增加一条边 $e$ , 使得原图中两个原本不相关联的两个顶点被连接起来。
新图： $(V,E\cup \{e\})$

/**  
 * * @param from 起点  
 * @param to 终点  
 * @param weight 权重  
 * @return 返回是否添加成功，一个布尔值  
 */  
public boolean addEdge(Integer from, Integer to, int weight) {  
    Node<V> fromNode = nodes.get(from);  
    Node<V> toNode = nodes.get(to);  
    //保证节点的有效性即可。  
    if(fromNode != null && toNode != null){  
        Edge<V> edge = new Edge<>(fromNode, toNode, weight);  
        edges.add(edge);//边集新添一条边  
        //更新fromNode顶点的信息；  
        fromNode.addNeighbor(toNode);//直接邻居加1  
        fromNode.addEdge(edge);//fromNode关联（作起点）的边数+1  
        return true;//删除成功  
    }  
    return false;//删除结点不存在  
}

你会发现该函数添加的是有向边。无向边怎么添加呢？调转from 和 to调用两次addEdge函数。

/**  
 * * @param from 起点  
 * @param to 终点  
 * @param weight 权重  
 * @return 返回是否添加成功，一个布尔值  
 */  
public boolean addEdge(Integer from, Integer to, int weight) {  
    Node<V> fromNode = nodes.get(from);  
    Node<V> toNode = nodes.get(to);  
    //保证节点的有效性即可。  
    if(fromNode != null && toNode != null){  
        Edge<V> edge = new Edge<>(fromNode, toNode, weight);  
        edges.add(edge);//边集新添一条边  
  
        //更新fromNode顶点的信息；  
        fromNode.addNeighbor(toNode);//直接邻居加1  
        fromNode.addEdge(edge);//fromNode关联（作起点）的边数+1  
        return true;//删除成功  
    }  
    return false;//删除结点不存在  
}  
  
/**  
 * * @param from 起点  
 * @param to 终点  
 * @param weight 权重  
 * @return 返回是否添加成功， 返回一个布尔值  
 */  
public boolean addEdgeDirect(Integer from, Integer to, int weight) {  
    return addEdge(from, to, weight);//增加一条有向边。  
}  
/**  
 * 添加一条无向边， 实际等效两条有向边。  
 * @param from 起点  
 * @param to 终点  
 * @param weight 权重  
 * @return 返回是否添加成功， 返回一个布尔值  
 */  
public boolean addEdgeUnDirect(Integer from, Integer to,int weight) {  
    return addEdge(from, to,weight) && addEdge(to,from,weight);  
}

1. `addEdge` 方法

功能：添加一条有向边。
参数：
- from：起点节点的ID。
- to：终点节点的ID。
- weight：边的权重。
返回值：布尔值，指示添加是否成功。
逻辑：
- 首先通过节点ID获取起点和终点节点。
- 检查两个节点是否有效（不为 null）。
- 创建新边并将其添加到边集中。
- 更新起点节点的邻接关系和边信息。

2. `addEdgeDirect` 方法

功能：直接调用 addEdge，添加一条有向边。
作用：提供更直观的命名，方便调用。

3. `addEdgeUnDirect` 方法

功能：添加一条无向边。
逻辑：
- 通过调用 addEdge 方法添加两条有向边（from 到 to 和 to 到 from），实现无向边的效果。
返回值：如果两个有向边都成功添加，则返回 true；否则返回 false。
。

可以自环吗？当然可以，只需要传参时from == to即可，代码上允许这种情况发生。
多重图呢？可以添加多重权重不同的边，例如，多次调用addEdge可以创造多条权值不同但方向，起点终点相同的边。注意，权值相同的边合并为1条。
你可能想吐槽一句？edges不是HashSet吗？它应该要去重啊，实际上这与hashcode方法和equal方法有关。HashSet会先调用hashcode方法，如果哈希值相同，然后调用equals方法，只需要重写Edge类的equals方法即可。

//Edge.java
Override  
public boolean equals(Object o){  
    if(this == o) return true;  
    if(o == null || getClass() != o.getClass()) return false;  
    Edge<?> edge = (Edge<?>) o;  
    if(weight != edge.weight) return false;  
    if(!Objects.equals(from, edge.from)) return false;  
    return Objects.equals(to, edge.to);  
}

只允许权值相同的多重边。

删除图中的边

/**  
 * 适用 无权有向图;无权无向图需要调换参数调用两次。  
 * 默认删除fromId->toId这条有向边。  
 * removeDirect删除有向边， removeUnDirect删除无向边（也适用单向边不过要耗时一些）  
 * @param fromId 起点编号  
 * @param toId 终点编号  
 */  
public void removeEdge(Integer fromId, Integer toId) {  
    Node<V> fromNode = nodes.get(fromId);  
    Node<V> toNode = nodes.get(toId);  
  
    if (fromNode != null && toNode != null) {  
        Iterator<Edge<V>> iterator = edges.iterator();  
        while (iterator.hasNext()) {  
            Edge<V> edge = iterator.next();  
            if (edge.from == fromNode && edge.to == toNode) {  
                iterator.remove(); // 安全地删除边  
                fromNode.edges.remove(edge);  
                fromNode.out--;  
                toNode.in--;  
                break; // 找到并删除后可以退出循环  
            }  
        }  
    }  
}  
  
/**  
 * 该方法会删除所有指定起点与终点相同的边（无视权重）  
 * 适用，带权有向图。无向图需要调换参数多调用一次  
 * @param fromId  
 * @param toId  
 */  
public void removeEdgeAll(Integer fromId, Integer toId) {  
    Node<V> fromNode = nodes.get(fromId);  
    Node<V> toNode = nodes.get(toId);  
  
    if (fromNode != null && toNode != null) {  
        Iterator<Edge<V>> iterator = edges.iterator();  
        while (iterator.hasNext()) {  
            Edge<V> edge = iterator.next();  
            if (edge.from == fromNode && edge.to == toNode) {  
                iterator.remove(); // 安全地删除边  
                fromNode.edges.remove(edge);  
                fromNode.out--;  
                toNode.in--;  
            }  
        }  
    }  
}  
  
/**  
 * 适用：无权有向图。带权图允许多重边，会随机干掉一条有向边。不带权的边唯一。  
 * 删除有向边  
 * @param fromId 起点编号  
 * @param toId 终点编号  
 */  
public void removeEdgeDirect(Integer fromId, Integer toId){  
    removeEdge(fromId, toId);  
}  
/**  
 * 适用：无权无向图。带权图允许多重边，会随机干掉一对无向边（无视权重）。不带权的边唯一。  
 * 删除无向边， 内部会调用两次removeDirect函数。  
 * @param fromId 起点编号  
 * @param toId 终点编号  
 */  
public void removeEdgeUnDirect(Integer fromId, Integer toId){  
    removeEdge(fromId, toId);  
    removeEdge(toId, fromId);  
}  
  
/**  
 * * @param fromId 起点编号  
 * @param toId 终点编号  
 * @param weight 权重  
 * @return 返回满足的有向边  
 */  
private Edge<V> search(Integer fromId, Integer toId, int weight) {  
    Node<V> fromNode = nodes.get(fromId);  
    Node<V> toNode = nodes.get(toId);  
    if (fromNode != null && toNode != null) {  
        Iterator<Edge<V>> iterator = edges.iterator();  
        while (iterator.hasNext()) {  
            Edge<V> edge = iterator.next();  
            if (edge.from == fromNode && edge.to == toNode && edge.weight == weight) {  
                return edge;  
            }  
        }  
    }  
    return null;  
}  
/**  
 * 适用：带权有向图。  
 * 删除指定带权有向边（如果存在）。  
 * @param fromId 起点编号  
 * @param toId 终点编号  
 * @param weight 权重  
 */  
public void removeEdgeWithWeight(Integer fromId, Integer toId, int weight){  
    Edge<V> edge = search(fromId, toId, weight);  
    if (edge != null) {  
        edges.remove(edge);  
        nodes.get(fromId).out--;  
        nodes.get(toId).in--;  
    }  
}  
  
/**  
 * 适用：带权无向图。  
 * 删除指定带权的无向边。  
 * @param fromId 起点编号  
 * @param toId 终点编号  
 * @param weight 权重  
 */  
public void removeEdgeWithWeightUnDirect(Integer fromId, Integer toId, int weight) {  
    removeEdgeWithWeight(fromId, toId, weight); // 删除有向边  
    removeEdgeWithWeight(toId, fromId, weight); // 删除反向边  
}

增加图中的顶点

增加一个孤立点，后续要跟其它顶点邻接就用增加边的方法。

/*  
 * 给定编号和值，创建一个新顶点并加入到图中。  
 * 若编号重复， 则添加失败。  
 * @param id 编号  
 * @param value 值  
 * @return 返回一个布尔值，添加成功了返回true。  
 */public boolean addNode(Integer id, V value) {  
    if (!nodes.containsKey(id)) {  
        nodes.put(id,new Node<V>(id,value));  
        return true;//删除成功  
    }  
    return false;//删除结点不存在  
}

删除图中的顶点

/**  
 * 删除节点  
 */  
public void removeNode(Integer id) {  
    // 移除点集的结点，并获取该节点以待后续处理。  
    Node<V> nodeToRemove = nodes.remove(id);  
  
    // 删除节点存在，则执行删除  
    if (nodeToRemove != null) {  
        // 删除与该节点相关的所有边  
        for (Node<V> neighbor : nodeToRemove.nexts) {  
            // 从邻居中移除与nodeToRemove的关联  
            neighbor.removeNeighbor(nodeToRemove);  
            // 安全地移除边  
            neighbor.edges.removeIf(edge -> edge.to == nodeToRemove);  
        }  
  
        // 移除与nodeToRemove相关的所有边  
        edges.removeIf(edge -> edge.from == nodeToRemove || edge.to == nodeToRemove);  
    }  
}

源码

Graph类

package graph;  
  
import java.util.*;  
  
/**  
 * @author Autumn Whispser * @param <V>  
 */  
public class Graph<V> {  
    /*将顶点按顺序编号 */    //构造点集--实际编号和具体的数据关联起来。  
    HashMap<Integer, Node<V>> nodes;  
    //存储边集  
    HashSet<Edge<V>> edges;  
    //构造函数  
    public Graph() {  
        //初始化点集和边集/  
        nodes = new HashMap<Integer, Node<V>>();  
        edges = new HashSet<Edge<V>>();  
    }  
    //判断图是否为空集  
    public boolean isEmpty() {  
        return nodes.isEmpty();  
    }  
    //获取顶点数量  
    public int size() {  
        return nodes.size();  
    }  
    //获取边的数量  
    public int sizeOfEdges(){  
        return edges.size();  
    }  
    /*  
     * 给定编号和值，创建一个新顶点并加入到图中。  
     * 若编号重复， 则添加失败。  
     * @param id 编号  
     * @param value 值  
     * @return 返回一个布尔值，添加成功了返回true。  
     */    public boolean addNode(Integer id, V value) {  
        if (!nodes.containsKey(id)) {  
            nodes.put(id,new Node<V>(id,value));  
            return true;//删除成功  
        }  
        return false;//删除结点不存在  
    }  
  
    /**  
     *     删除节点  
     */  
    public void removeNode(Integer id) {  
        //移除点集的结点， 并且获取该值以待后续处理。  
        Node<V> nodeToRemove = nodes.remove(id);  
        //删除结点是存在的， 则执行删除  
        if (nodeToRemove != null) {  
            // 边集:删除与该节点相关的所有边---for each循环实现  
            for(Node<V> neighbor: nodeToRemove.nexts){  
                //删除邻居之间可能的关联  
                removeEdgeDirect(neighbor.id,nodeToRemove.id);  
                //所有邻居的入度-1，因为有序关联nodeToReove都要执行删除。  
                neighbor.in--;  
            }  
            for (Edge<V> edge : new HashSet<>(edges)) {  
                if (edge.getFrom() == nodeToRemove || edge.getTo() == nodeToRemove) {  
                    edges.remove(edge);  
                }  
            }  
            // 更新移除结点所有邻居的入度。 移除的nodeToRemove不需要处理。  
            for (Node<V> neighbor : nodeToRemove.getNexts()) {  
            }  
        }  
    }  
  
  
    /**  
     *     * @param from 起点  
     * @param to 终点  
     * @param weight 权重  
     * @return 返回是否添加成功，一个布尔值  
     */  
    public boolean addEdge(Integer from, Integer to, int weight) {  
        Node<V> fromNode = nodes.get(from);  
        Node<V> toNode = nodes.get(to);  
        //保证节点的有效性即可。  
        if(fromNode != null && toNode != null){  
            Edge<V> edge = new Edge<>(fromNode, toNode, weight);  
            edges.add(edge);//边集新添一条边  
  
            //更新fromNode顶点的信息；  
            fromNode.addNeighbor(toNode);//直接邻居加1  
            fromNode.addEdge(edge);//fromNode关联（作起点）的边数+1  
            return true;//删除成功  
        }  
        return false;//删除结点不存在  
    }  
  
    /**  
     *     * @param from 起点  
     * @param to 终点  
     * @param weight 权重  
     * @return 返回是否添加成功， 返回一个布尔值  
     */  
    public boolean addEdgeDirect(Integer from, Integer to, int weight) {  
        return addEdge(from, to, weight);//增加一条有向边。  
    }  
    /**  
     * 添加一条无向边， 实际等效两条有向边。  
     * @param from 起点  
     * @param to 终点  
     * @param weight 权重  
     * @return 返回是否添加成功， 返回一个布尔值  
     */  
    public boolean addEdgeUnDirect(Integer from, Integer to,int weight) {  
        return addEdge(from, to,weight) && addEdge(to,from,weight);  
    }  
  
    /**  
     * 适用 无权有向图;无权无向图需要调换参数调用两次。  
     * 默认删除fromId->toId这条有向边。  
     * removeDirect删除有向边， removeUnDirect删除无向边（也适用单向边不过要耗时一些）  
     * @param fromId 起点编号  
     * @param toId 终点编号  
     */  
    public void removeEdge(Integer fromId, Integer toId) {  
        Node<V> fromNode = nodes.get(fromId);  
        Node<V> toNode = nodes.get(toId);  
  
        if (fromNode != null && toNode != null) {  
            Iterator<Edge<V>> iterator = edges.iterator();  
            while (iterator.hasNext()) {  
                Edge<V> edge = iterator.next();  
                if (edge.from == fromNode && edge.to == toNode) {  
                    iterator.remove(); // 安全地删除边  
                    fromNode.edges.remove(edge);  
                    fromNode.out--;  
                    toNode.in--;  
                    break; // 找到并删除后可以退出循环  
                }  
            }  
        }  
    }  
  
    /**  
     * 该方法会删除所有指定起点与终点相同的边（无视权重）  
     * 适用，带权有向图。无向图需要调换参数多调用一次  
     * @param fromId  
     * @param toId  
     */  
    public void removeEdgeAll(Integer fromId, Integer toId) {  
        Node<V> fromNode = nodes.get(fromId);  
        Node<V> toNode = nodes.get(toId);  
  
        if (fromNode != null && toNode != null) {  
            Iterator<Edge<V>> iterator = edges.iterator();  
            while (iterator.hasNext()) {  
                Edge<V> edge = iterator.next();  
                if (edge.from == fromNode && edge.to == toNode) {  
                    iterator.remove(); // 安全地删除边  
                    fromNode.edges.remove(edge);  
                    fromNode.out--;  
                    toNode.in--;  
                }  
            }  
        }  
    }  
  
    /**  
     * 适用：无权有向图。带权图允许多重边，会随机干掉一条有向边。不带权的边唯一。  
     * 删除有向边  
     * @param fromId 起点编号  
     * @param toId 终点编号  
     */  
    public void removeEdgeDirect(Integer fromId, Integer toId){  
        removeEdge(fromId, toId);  
    }  
    /**  
     * 适用：无权无向图。带权图允许多重边，会随机干掉一对无向边（无视权重）。不带权的边唯一。  
     * 删除无向边， 内部会调用两次removeDirect函数。  
     * @param fromId 起点编号  
     * @param toId 终点编号  
     */  
    public void removeEdgeUnDirect(Integer fromId, Integer toId){  
        removeEdge(fromId, toId);  
        removeEdge(toId, fromId);  
    }  
  
    /**  
     *     * @param fromId 起点编号  
     * @param toId 终点编号  
     * @param weight 权重  
     * @return 返回满足的有向边  
     */  
    private Edge<V> search(Integer fromId, Integer toId, int weight) {  
        Node<V> fromNode = nodes.get(fromId);  
        Node<V> toNode = nodes.get(toId);  
        if (fromNode != null && toNode != null) {  
            Iterator<Edge<V>> iterator = edges.iterator();  
            while (iterator.hasNext()) {  
                Edge<V> edge = iterator.next();  
                if (edge.from == fromNode && edge.to == toNode && edge.weight == weight) {  
                    return edge;  
                }  
            }  
        }  
        return null;  
    }  
    /**  
     * 适用：带权有向图。  
     * 删除指定带权有向边（如果存在）。  
     * @param fromId 起点编号  
     * @param toId 终点编号  
     * @param weight 权重  
     */  
    public void removeEdgeWithWeight(Integer fromId, Integer toId, int weight){  
        Edge<V> edge = search(fromId, toId, weight);  
        if (edge != null) {  
            edges.remove(edge);  
            nodes.get(fromId).out--;  
            nodes.get(toId).in--;  
        }  
    }  
  
    /**  
     * 适用：带权无向图。  
     * 删除指定带权的无向边。  
     * @param fromId 起点编号  
     * @param toId 终点编号  
     * @param weight 权重  
     */  
    public void removeEdgeWithWeightUnDirect(Integer fromId, Integer toId, int weight) {  
        removeEdgeWithWeight(fromId, toId, weight); // 删除有向边  
        removeEdgeWithWeight(toId, fromId, weight); // 删除反向边  
    }  
  
  
    //    @Override  
//    public boolean equals(Object o) {  
//        if (this == o) return true;  
//        if (o == null || getClass() != o.getClass()) return false;  
//        Graph<?> graph = (Graph<?>) o;  
//  
//    }  
    public boolean isSameGraph(Graph<V> other) {  
        if (nodes.size() != other.nodes.size() || edges.size() != other.edges.size()) {  
            return false; // 如果节点或边的数量不同，直接返回 false        }  
        //检查点集  
        for (Map.Entry<Integer, Node<V>> entry : nodes.entrySet()) {  
            Node<V> otherNode = other.nodes.get(entry.getKey());  
            if (otherNode == null || !entry.getValue().value.equals(otherNode.value)) {  
                return false; // 检查节点的值  
            }  
        }  
  
        // 检查边  
        for (Edge<V> edge : edges) {  
            Edge<V> otherEdge = other.edges.stream()  
                    .filter(e -> e.from.id == edge.from.id && e.to.id == edge.to.id)  
                    .findFirst().orElse(null);  
            if (otherEdge == null || edge.weight != otherEdge.weight) {  
                return false; // 检查边的权重  
            }  
        }  
        return true;  
    }  
    /**  
     * 该方法会合并另一个图. 进行深拷贝。  
     * 这里假定编码唯一。重复了的id则不添加。  
     * @param other 另一个图  
     */  
   public void union(Graph<V> other) {  
       if(!isSameGraph(other)){  
           return ;//相同图不用合并。  
       }  
        Graph<V> newGraph = other.deepCopy();  
        //合并点集  
       for(Map.Entry<Integer, Node<V>> entry : newGraph.nodes.entrySet()){  
           Integer id = entry.getKey();  
           if(!nodes.containsKey(id)){  
               Node<V> node = entry.getValue();  
               nodes.put(id,node);  
           }  
       }  
       // 合并边集，避免重复边  
       for (Edge<V> edge : newGraph.edges) {  
           if (!edges.contains(edge)) {  
               edges.add(edge);  
               edge.from.addEdge(edge); // 更新起点的边  
               edge.from.addNeighbor(edge.to); // 更新邻接关系  
           }  
       }  
  
   }  
    public void contractNodes(Node<V> u, Node<V> v) {  
        if (u == null || v == null || u == v) {  
            return; // 空引用或自环的情况无法进行边收缩。  
        }  
  
        // 合并两个顶点的值  
        V newValue = mergeValues(u.getValue(), v.getValue());  
        // 创建新节点，使用其中一个顶点的ID  
        Node<V> newNode = new Node<>(u.getId(), newValue);  
  
        // 更新边的起点和终点  
        for (Edge<V> edge : edges) {  
            if (edge.from == u || edge.from == v) {  
                edge.from = newNode;  
            }  
            if (edge.to == u || edge.to == v) {  
                edge.to = newNode;  
            }  
        }  
  
        // 删除原有的节点  
        nodes.remove(u.id);  
        nodes.remove(v.id);  
  
        // 添加新节点到图中  
        nodes.put(newNode.id, newNode);  
    }  
  
    private V mergeValues(V value1, V value2) {  
        // 自定义合并逻辑  
        // 例如，可以选择返回一个合并后的值，或根据特定规则进行选择  
        return value1; // 示例：简单返回第一个值  
    }  
  
    public Graph<V> deepCopy() {  
        Graph<V> newGraph = new Graph<>();  
  
        // 先深拷贝点集:复制节点  
        for (Map.Entry<Integer, Node<V>> entry : nodes.entrySet()) {  
            Node<V> originalNode = entry.getValue();  
            Node<V> newNode = new Node<>(originalNode.id, originalNode.value);  
            newGraph.nodes.put(entry.getKey(), newNode);  
        }  
  
        // 然后复制边并建立关联  
        //遍历原图的边， 获取权重， 根据id来建立新节点的联系。 保证新节点关联边与原图逻辑上是一致的。  
        for (Edge<V> edge : edges) {  
            //根据编号id操作新图  
  
            //操作新图， 根据id获取起点终点，两个图建立联系是通过id。  
            Node<V> fromNode = newGraph.nodes.get(edge.from.id);  
            Node<V> toNode = newGraph.nodes.get(edge.to.id);  
            Edge<V> newEdge = new Edge<>(fromNode, toNode, edge.weight);  
            newGraph.edges.add(newEdge);  
            fromNode.addEdge(newEdge); // 更新起点的边  
            fromNode.addNeighbor(toNode); // 更新邻接关系  
        }  
  
        return newGraph;  
    }  
    /*查找*/  
    Edge<V> searchEdge(Node<V> from, Node<V> to){  
       for (Edge<V> edge : edges) {  
           if (edge.getFrom() == from && edge.getTo() == to) {  
               return edge;  
           }  
       }  
       return null;  
    }  
    /*查找带权边 */    Edge<V> searchEdgeWithWeight(Node<V> from, Node<V> to, int weight){  
       for (Edge<V> edge : edges) {  
           if (edge.getFrom() == from && edge.getTo() == to && edge.getWeight() == weight) {  
               return edge;  
           }  
       }  
       return null;  
    }  
}

Node类

package graph;  
  
import java.util.ArrayList;  
import java.util.Collections;  
import java.util.List;  
import java.util.Objects;  
  
/**  
 * @author AutumnWhisper * 回顾离散数学  
 */  
public class Node<V> {  
    int id;//编号  
    //顶点存储的值  
    V value;  
    //入度  
    int in;  
    //出度  
    int out;  
    //直接可达结点表:顶点V的所有相邻顶点的集合.====直接邻居  
    ArrayList<Node<V>> nexts;  
    //存储以该节点为起点的有向边。  
    ArrayList<Edge<V>> edges;  
  
    //初始化默认顶点为孤立点  
    public Node(int id,V value) {  
        this.id = id;  
        this.value = value;  
        this.in = 0;  
        this.out = 0;  
        this.nexts = new ArrayList<>();  
        this.edges = new ArrayList<>();  
    }  
    //获取当前顶点的编号  
    public int getId() {  
        return id;  
    }  
    //获取当前节点存储的有效值  
    public V getValue() {  
        return value;  
    }  
    //设置当前节点存储的值  
    public V setValue(V value) {  
        V oldVal = this.value;  
        this.value = value;  
        return oldVal;  
    }  
    //获取入度  
    public int getIn(){  
        return in;  
    }  
    //获取出度  
    public int getOut(){  
        return out;  
    }  
    //提供当前顶点的邻接顶点列表（不可修改）  
    public List<Node<V>> getNexts(){  
        return Collections.unmodifiableList(nexts);  
    }  
    //提供以当前结点为顶点的关联边数。(不可修改)  
    public List<Edge<V>> getEdges(){  
        return Collections.unmodifiableList(edges);  
    }  
  
    @Override  
    public boolean equals(Object obj) {  
        if (this == obj) return true;  
        if (obj == null || getClass() != obj.getClass()) return false;  
        Node<?> node = (Node<?>) obj;  
  
        return id == node.id &&  
                in == node.in &&  
                out == node.out &&  
                (Objects.equals(value, node.value)) &&  
                nexts.equals(node.nexts) &&  
                edges.equals(node.edges);  
    }  
  
    @Override  
    public int hashCode() {  
        int result = Integer.hashCode(id);  
        result = 31 * result + (value != null ? value.hashCode() : 0);  
        result = 31 * result + Integer.hashCode(in);  
        result = 31 * result + Integer.hashCode(out);  
        result = 31 * result + nexts.hashCode();  
        result = 31 * result + edges.hashCode();  
        return result;  
    }  
  
    /**  
     * 当前节点新增邻居  
     * @param neighbor 邻居  
     */  
    void addNeighbor(Node<V> neighbor){  
        nexts.add(neighbor);  
        this.out++;//当前节点出度+1  
        neighbor.in++;//邻居入度+1  
    }  
    /**  
     * 当前节点删除邻居  
     * 不对边关系有任何处理  
     * 处理度数  
     */  
    void removeNeighbor(Node<V> neighbor){  
        nexts.remove(neighbor);  
        this.in--;  
        neighbor.out--;  
    }  
    /**  
     * 当前节点新增边  
     * @param edge 边  
     */  
    void addEdge(Edge<V> edge){  
        edges.add(edge);  
    }  
    /**  
     *     */    void removeEdge(Edge<V> edge){  
        edges.remove(edge);  
    }  
}

Edge类

package graph;  
  
import java.util.Objects;  
  
//顶点不依赖边， 边依赖顶点  
public class Edge<V> {  
    //权重  
    int weight;  
    Node<V> from;//起点  
    Node<V> to;//终点  
    //边依赖顶点的条数。  
    public Edge(int weight, Node<V> from, Node<V> to) {  
        this.weight = weight;  
        this.from = from;  
        this.to = to;  
    }  
  
    public Edge(Node<V> from, Node<V> to, int weight) {  
        this.weight = weight;  
        this.from = from;  
        this.to = to;  
    }  
  
    //用户提供的接口。  
    //获取权重  
    public int getWeight() {  
        return weight;  
    }  
    //重新设置权重  
    public void setWeight(int weight) {  
        this.weight = weight;  
    }  
    //获取边的起点  
    public Node<V> getFrom() {  
        return from;  
    }  
    //设置边的起点  
    public void setFrom(Node<V> from) {  
        this.from = from;  
    }  
    //获取边的终点  
    public Node<V> getTo() {  
        return to;  
    }  
    //设置边的终点  
    public void setTo(Node<V> to) {  
        this.to = to;  
    }  
  
    @Override  
    public boolean equals(Object o){  
        if(this == o) return true;  
        if(o == null || getClass() != o.getClass()) return false;  
        Edge<?> edge = (Edge<?>) o;  
        if(weight != edge.weight) return false;  
        if(!Objects.equals(from, edge.from)) return false;  
        return Objects.equals(to, edge.to);  
    }  
}