概念
图是由顶点和边组成的一种数据结构，我们之前介绍的树形结构中，树的每一个节点就是顶点，顶点与顶点中的连线就是边，也就是说，树是一种特殊的图
图中的边如果有方向，那么这个图就称为有向图，反之则成为无向图
完全图
如果一个无向图中任意两个节点之间有且仅有一条边，那么称这个图为无向完全图，而一个有向图中，任意两个节点间有且仅有方向相反的边，称之为有向完全图
下图中左侧为无向完全图，右侧为有向完全图
顶点的度
指的是有几条边与该节点关联，如果是完全图的话，那么分为入度和出度，箭头指向该节点的是这个节点的入度，反之为出度
下图中左侧的所有节点的度都是2，右侧所有节点的入度都是2，出度都是2，也即是所有节点的度都是4
路径
一个节点到另一个节点要走的边称之为路径，如果这些边上有权值（例如一个节点是北京，一个是天津，一个是上海，那么北京到天津的权值和北京到上海的权值是不一样的）
对于无向图，两个节点间的路径长度等于边的个数
对于有向图，两个节点间的路径长度等于所有边的权值之和
回路和环
对于一个路径，如果起点和终点都一样，那么称这个路径为回路，而如果这个路径的长度为一，也就是这个边是自己指向自己，称之为环
上图中黑色的三条边组成回路，红色的是环
子图
对于图G，如果图G1的节点都属于图G，边都属于图G，则称G1为G的子图
例如上图，右面的图就是左侧的图的子图
连通图
如果无向图中任意两个节点间都是有一条路径的，则称这个图是连通图
如果有向图中任意两个节点间都是有一条从起始点到终止点的路径，还有一条从终止点到起始点的路径，则称这个图是强连通图
一个连通图的最小连通子图是该图的生成树
图的存储
在计算机中，主要有下面两种方法来存储图
邻接矩阵
使用矩阵（二维数组来存储节点与节点之间的关系）
对于无向图，两个节点之间如果有边，就是1，或者是边的权值，没有就是0，自己和自己是0，因此，无向图的邻接矩阵表示是关于对角线对称的
对于有向图，一个节点如果有指向另一个节点的边，就是1或者是边的权值，否则就是正无穷，自己和自己是0
代码实现
定义一个最大值代表正无穷
public class Constant {
public static final int MAX = Integer.MAX_VALUE;
}
import java.util.Arrays;
/**
* 使用邻接矩阵存储图
*/
public class GraphByMatrix {
private char[] arrayV;//顶点数组
private int[][] matrix;//邻接矩阵
private boolean isDirect;//是否为有向图
/**
* @param size 当前矩阵的顶点个数
* @param isDirect
*/
public GraphByMatrix(int size, boolean isDirect){
this.arrayV = new char[size];
matrix = new int[size][size];
for (int i = 0; i < size; i++) {
Arrays.fill(matrix[i],Constant.MAX);
}
this.isDirect = isDirect;
}
/**
* 初始化顶点数组
* @param array
*/
public void initArrayV(char[] array){
for (int i = 0; i < arrayV.length; i++) {
arrayV[i] = array[i];
}
}
/**
* 添加边
* @param srcV 起点
* @param destV 终点
* @param weight 权值
*/
public void addEdge(char srcV, char destV, int weight){
int srcIndex = getIndexOfV(srcV);
int destIndex = getIndexOfV(destV);
matrix[srcIndex][destIndex] = weight;
//无向图的对称位置也有对应的权值
if(!isDirect){
matrix[destIndex][srcIndex] = weight;
}
}
/**
* 获取v顶点的下标
* @param v
* @return
*/
private int getIndexOfV(char v){
for (int i = 0; i < arrayV.length; i++) {
if (arrayV[i] == v){
return i;
}
}
return -1;
}
/**
* 获取顶点的度
* 有向图为入度+出度
* @param v
* @return
*/
public int getDevOfV(char v){
int count = 0;
int srcIndex = getIndexOfV(v);
//计算出度
for (int i = 0; i < arrayV.length; i++) {
if(matrix[srcIndex][i] != Constant.MAX){
count++;
}
}
//计算入度
if(isDirect){
for (int i = 0; i < arrayV.length; i++) {
if(matrix[i][srcIndex] != Constant.MAX){
count++;
}
}
}
return count;
}
private void printGraph() {
for (int i = 0; i < arrayV.length; i++) {
System.out.print(arrayV[i] + " ");
}
System.out.println();
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
if(matrix[i][j] == Constant.MAX){
System.out.print("∞ ");
} else {
System.out.print(matrix[i][j] + " ");
}
}
System.out.println();
}
}
public static void main(String[] args) {
GraphByMatrix graph = new GraphByMatrix(4,true);
char[] array = {'A','B','C','D'};
graph.initArrayV(array);
graph.addEdge('A','B',1);
graph.addEdge('A','D',1);
graph.addEdge('B','A',1);
graph.addEdge('B','C',1);
graph.addEdge('C','B',1);
graph.addEdge('C','D',1);
graph.addEdge('D','A',1);
graph.addEdge('D','C',1);
graph.printGraph();
System.out.println(graph.getDevOfV('A'));
}
}
邻接表
使用数组来表示顶点的集合，使用链表来表示边的关系
也就是说，每一个链表中存储了目标顶点所在的下标
而如果是有向图，那么会存储两个表，一个是入边表，另一个则是出边表
代码实现
import java.util.ArrayList;
/**
* 使用邻接表存储图
*/
public class GraphByNode {
static class Node{
public int src;//起始位置
public int dest;//目标位置
public int weight;//权重
public Node next;
public Node(int src, int dest, int weight) {
this.src = src;
this.dest = dest;
this.weight = weight;
}
}
public char[] arrayV;//存储顶点
public ArrayList<Node> edgList;//存储边
public boolean isDirect;
public GraphByNode(int size, boolean isDirect){
this.arrayV = new char[size];
edgList = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
edgList.add(null);
}
this.isDirect = isDirect;
}
/**
* 初始化顶点数组
* @param array
*/
public void initArrayV(char[] array){
for (int i = 0; i < arrayV.length; i++) {
arrayV[i] = array[i];
}
}
/**
* 添加边
* @param srcV
* @param destV
* @param weight
*/
public void addEdge(char srcV, char destV, int weight){
int srcIndex = getIndexOfV(srcV);
int destIndex = getIndexOfV(destV);
addEdgeChild(srcIndex,destIndex,weight);
if(!isDirect){
addEdgeChild(destIndex,srcIndex,weight);
}
}
private void addEdgeChild(int srcIndex, int destIndex, int weight){
Node cur = edgList.get(srcIndex);
while(cur != null){
if(cur.dest == destIndex){
return;
}
cur = cur.next;
}
//之前没有存储过这条边
//头插法
Node node = new Node(srcIndex,destIndex,weight);
node.next = edgList.get(srcIndex);
edgList.set(srcIndex,node);
}
/**
* 获取v顶点的下标
* @param v
* @return
*/
private int getIndexOfV(char v){
for (int i = 0; i < arrayV.length; i++) {
if (arrayV[i] == v){
return i;
}
}
return -1;
}
/**
* 获取顶点的度
* @param v
* @return
*/
public int getDevOfV(char v){
int count = 0;
int srcIndex = getIndexOfV(v);
Node cur = edgList.get(srcIndex);
while(cur != null){
count++;
cur = cur.next;
}
if(isDirect){
int destIndex = srcIndex;
for (int i = 0; i < arrayV.length; i++) {
if(i == destIndex){
continue;
} else {
Node pCur = edgList.get(i);
while(pCur != null){
if(pCur.dest == destIndex){
count++;
}
pCur = pCur.next;
}
}
}
}
return count;
}
public void printGraph(){
for (int i = 0; i < arrayV.length; i++) {
System.out.println(arrayV[i] + " ->");
Node cur = edgList.get(i);
while(cur != null){
System.out.print(arrayV[cur.dest] + " ->");
cur = cur.next;
}
System.out.println();
}
}
public static void main(String[] args) {
GraphByNode graph = new GraphByNode(4,true);
char[] array = {'A','B','C','D'};
graph.initArrayV(array);
graph.addEdge('A','B',1);
graph.addEdge('A','D',1);
graph.addEdge('B','A',1);
graph.addEdge('B','C',1);
graph.addEdge('C','B',1);
graph.addEdge('C','D',1);
graph.addEdge('D','A',1);
graph.addEdge('D','C',1);
graph.printGraph();
System.out.println(graph.getDevOfV('A'));
}
}
全部代码
import java.util.*;
/**
* 使用邻接矩阵存储图
*/
public class GraphByMatrix {
private char[] arrayV;//顶点数组
private int[][] matrix;//邻接矩阵
private boolean isDirect;//是否为有向图
/**
* @param size 当前矩阵的顶点个数
* @param isDirect
*/
public GraphByMatrix(int size, boolean isDirect){
this.arrayV = new char[size];
matrix = new int[size][size];
for (int i = 0; i < size; i++) {
Arrays.fill(matrix[i],Constant.MAX);
}
this.isDirect = isDirect;
}
/**
* 初始化顶点数组
* @param array
*/
public void initArrayV(char[] array){
for (int i = 0; i < arrayV.length; i++) {
arrayV[i] = array[i];
}
}
/**
* 添加边
* @param srcV 起点
* @param destV 终点
* @param weight 权值
*/
public void addEdge(char srcV, char destV, int weight){
int srcIndex = getIndexOfV(srcV);
int destIndex = getIndexOfV(destV);
matrix[srcIndex][destIndex] = weight;
//无向图的对称位置也有对应的权值
if(!isDirect){
matrix[destIndex][srcIndex] = weight;
}
}
/**
* 获取v顶点的下标
* @param v
* @return
*/
private int getIndexOfV(char v){
for (int i = 0; i < arrayV.length; i++) {
if (arrayV[i] == v){
return i;
}
}
return -1;
}
/**
* 获取顶点的度
* 有向图为入度+出度
* @param v
* @return
*/
public int getDevOfV(char v){
int count = 0;
int srcIndex = getIndexOfV(v);
//计算出度
for (int i = 0; i < arrayV.length; i++) {
if(matrix[srcIndex][i] != Constant.MAX){
count++;
}
}
//计算入度
if(isDirect){
for (int i = 0; i < arrayV.length; i++) {
if(matrix[i][srcIndex] != Constant.MAX){
count++;
}
}
}
return count;
}
private void printGraph() {
for (int i = 0; i < arrayV.length; i++) {
System.out.print(arrayV[i] + " ");
}
System.out.println();
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
if(matrix[i][j] == Constant.MAX){
System.out.print("∞ ");
} else {
System.out.print(matrix[i][j] + " ");
}
}
System.out.println();
}
}
/**
* 广度优先遍历
* @param v
*/
public void bfs(char v){
boolean[] visited = new boolean[arrayV.length]; //close表
Queue<Integer> queue = new LinkedList<>();
int srcIndex = getIndexOfV(v);
queue.offer(srcIndex);
while(!queue.isEmpty()){
int top = queue.poll();
System.out.print(arrayV[top] + "->");
visited[top] = true;
for (int i = 0; i < arrayV.length; i++) {
if(matrix[top][i] != Constant.MAX && visited[i] == false){
queue.offer(i);
visited[i] = true;
}
}
}
}
/**
* 深度优先遍历
* @param v
*/
public void dfs(char v){
boolean[] visited = new boolean[arrayV.length]; //close表
int srcIndex = getIndexOfV(v);
dfsChild(srcIndex,visited);
}
private void dfsChild(int srcIndex, boolean visited[]){
System.out.print(arrayV[srcIndex] + "->");
visited[srcIndex] = true;
for (int i = 0; i < arrayV.length; i++) {
if(matrix[srcIndex][i] != Constant.MAX && visited[i] == false){
dfsChild(i,visited);
}
}
}
/**
* 边的抽象类
*/
static class Edge{
public int srcIndex;
public int destIndex;
public int weight;
public Edge(int srcIndex, int destIndex, int weight) {
this.srcIndex = srcIndex;
this.destIndex = destIndex;
this.weight = weight;
}
}
/**
* 求最小生成子树
* @param minTree 存储找到的边
* @return 最小生成树的权值和
*/
public int kruskal(GraphByMatrix minTree){
//存储所有的边
PriorityQueue<Edge> minQ = new PriorityQueue<>(new Comparator<Edge>() {
@Override
public int compare(Edge o1, Edge o2) {
return o1.weight - o2.weight;
}
});
int n = arrayV.length;
UnionFindSet ufs = new UnionFindSet(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if(i < j && matrix[i][j] != Constant.MAX){
minQ.offer(new Edge(i, j, matrix[i][j]));
}
}
}
int size = 0;
int totalWight = 0;
while(size < n - 1 && !minQ.isEmpty()){
Edge edge = minQ.poll();
int srcIndex = edge.srcIndex;
int destIndex = edge.destIndex;
if(!ufs.isSameUnionFindSet(srcIndex,destIndex)){
minTree.addEdgeUseIndex(srcIndex,destIndex,edge.weight);
size++;
totalWight += edge.weight;
ufs.union(srcIndex, destIndex);
}
}
if(size == n - 1){
return totalWight;
} else {
return -1;
}
}
private void addEdgeUseIndex(int srcIndex, int destIndex, int weight){
matrix[srcIndex][destIndex] = weight;
//无向图的对称位置也有对应的权值
if(!isDirect){
matrix[destIndex][srcIndex] = weight;
}
}
/**
* 求最小生成子树
* @param minTree
* @param chv 起始点
* @return
*/
public int prim(GraphByMatrix minTree, char chv){
int srcIndex = getIndexOfV(chv);
//存储已经确定的点
Set<Integer> setX = new HashSet<>();
setX.add(srcIndex);
//存储尚未确定的点
Set<Integer> setY = new HashSet<>();
int n = arrayV.length;
for (int i = 0; i < n; i++) {
if(i != srcIndex){
setY.add(i);
}
}
//存储所有的边
PriorityQueue<Edge> minQ = new PriorityQueue<>(new Comparator<Edge>() {
@Override
public int compare(Edge o1, Edge o2) {
return o1.weight - o2.weight;
}
});
//将所有与起始点有关的边放到优先级队列中
for (int i = 0; i < n; i++) {
if(matrix[srcIndex][i] != Constant.MAX){
minQ.offer(new Edge(srcIndex, i, matrix[srcIndex][i]));
}
}
int size = 0;
int totalWeight = 0;
while(!minQ.isEmpty()){
Edge min = minQ.poll();
int srcI = min.srcIndex;
int desT = min.destIndex;
if(setX.contains(desT)){
//构成环
} else {
minTree.addEdgeUseIndex(srcI, desT, min.weight);
size++;
totalWeight += min.weight;
if(size == n - 1){
return totalWeight;
}
//更新两个集合中的节点
setX.add(desT);
setY.remove(desT);
//将desT连接的所有边放到minQ
for (int i = 0; i < n; i++) {
if(matrix[desT][i] != Constant.MAX && !setX.contains(i)){
minQ.offer(new Edge(desT, i, matrix[desT][i]));
}
}
}
}
return -1;
}
public static void testGraphMinTreeKruskal() {
String str = "abcdefghi";
char[] array =str.toCharArray();
GraphByMatrix g = new GraphByMatrix(str.length(),false);
g.initArrayV(array);
g.addEdge('a', 'b', 4);
g.addEdge('a', 'h', 8);
//g.addEdge('a', 'h', 9);
g.addEdge('b', 'c', 8);
g.addEdge('b', 'h', 11);
g.addEdge('c', 'i', 2);
g.addEdge('c', 'f', 4);
g.addEdge('c', 'd', 7);
g.addEdge('d', 'f', 14);
g.addEdge('d', 'e', 9);
g.addEdge('e', 'f', 10);
g.addEdge('f', 'g', 2);
g.addEdge('g', 'h', 1);
g.addEdge('g', 'i', 6);
g.addEdge('h', 'i', 7);
GraphByMatrix kminTree = new GraphByMatrix(str.length(),false);
System.out.println(g.kruskal(kminTree));
kminTree.printGraph();
}
public static void testGraphMinTreePrim() {
String str = "abcdefghi";
char[] array = str.toCharArray();
GraphByMatrix g = new GraphByMatrix(str.length(), false);
g.initArrayV(array);
g.addEdge('a', 'b', 4);
g.addEdge('a', 'h', 8);
//g.addEdge('a', 'h', 9);
g.addEdge('b', 'c', 8);
g.addEdge('b', 'h', 11);
g.addEdge('c', 'i', 2);
g.addEdge('c', 'f', 4);
g.addEdge('c', 'd', 7);
g.addEdge('d', 'f', 14);
g.addEdge('d', 'e', 9);
g.addEdge('e', 'f', 10);
g.addEdge('f', 'g', 2);
g.addEdge('g', 'h', 1);
g.addEdge('g', 'i', 6);
g.addEdge('h', 'i', 7);
GraphByMatrix primTree = new GraphByMatrix(str.length(), false);
System.out.println(g.prim(primTree, 'a'));
primTree.printGraph();
}
/**
* 查找两节点最短路径
* @param vSrc 指定的节点
* @param dist 距离数组
* @param pPath 路径
*/
public void dijkstra(char vSrc, int[] dist, int[] pPath){
int srcIndex = getIndexOfV(vSrc);
//初始化距离数组
Arrays.fill(dist,Constant.MAX);
dist[srcIndex] = 0;
//初始化路径数组
Arrays.fill(pPath,-1);
pPath[srcIndex] = 0;
//创建数组，记录当前节点是否被记录
int n = arrayV.length;
boolean[] s = new boolean[n];
//n个顶点
for (int k = 0; k < n; k++) {
int min = Constant.MAX; //最小值
int u = srcIndex; //最小值下标
for (int i = 0; i < n; i++) {
if(s[i] == false && dist[i] < min){
min = dist[i];
u = i;
}
}
s[u] = true;
//松弛与u有关的所有顶点
for (int v = 0; v < n; v++) {
if(s[v] == false && matrix[u][v] != Constant.MAX && dist[u] + matrix[u][v] < dist[v]){
dist[v] = dist[u] + matrix[u][v];//更新距离
pPath[v] = u;//更新路径
}
}
}
}
public void printShortPath(char vSrc, int[] dist, int[] pPath){
int srcIndex = getIndexOfV(vSrc);
int n = arrayV.length;
for (int i = 0; i < n; i++) {
if(i != srcIndex){
ArrayList<Integer> path = new ArrayList<>();
int pathI = i;
while(pathI != srcIndex){
path.add(pathI);
pathI = pPath[pathI];
}
path.add(srcIndex);
Collections.reverse(path);
for (int pos: path){
System.out.print(arrayV[pos] + "-> ");
}
System.out.println(dist[i]);
}
}
}
public static void testGraphDijkstra() {
String str = "syztx";
char[] array = str.toCharArray();
GraphByMatrix g = new GraphByMatrix(str.length(),true);
g.initArrayV(array);
g.addEdge('s', 't', 10);
g.addEdge('s', 'y', 5);
g.addEdge('y', 't', 3);
g.addEdge('y', 'x', 9);
g.addEdge('y', 'z', 2);
g.addEdge('z', 's', 7);
g.addEdge('z', 'x', 6);
g.addEdge('t', 'y', 2);
g.addEdge('t', 'x', 1);
g.addEdge('x', 'z', 4);
int[] dist = new int[array.length];
int[] parentPath = new int[array.length];
g.dijkstra('s', dist, parentPath);
g.printShortPath('s', dist, parentPath);
}
public boolean bellmanFord(char vSrc, int[] dist, int[] pPath){
int srcIndex = getIndexOfV(vSrc);
//初始化距离数组
Arrays.fill(dist,Constant.MAX);
dist[srcIndex] = 0;
//初始化路径数组
Arrays.fill(pPath,-1);
pPath[srcIndex] = 0;
int n = arrayV.length;
//更新n次
for (int k = 0; k < n; k++) {
//遍历矩阵的每一个元素
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if(matrix[i][j] != Constant.MAX && dist[i] + matrix[i][j] < dist[j]){
dist[j] = dist[i] + matrix[i][j];
pPath[j] = i;
}
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if(matrix[i][j] != Constant.MAX && dist[i] + matrix[i][j] < dist[j]){
//存在负权回路
return false;
}
}
}
return true;
}
public static void testGraphBellmanFord() {
String str = "syztx";
char[] array = str.toCharArray();
GraphByMatrix g = new GraphByMatrix(str.length(),true);
g.initArrayV(array);
/* g.addEdge('s', 't', 6);
g.addEdge('s', 'y', 7);
g.addEdge('y', 'z', 9);
g.addEdge('y', 'x', -3);
g.addEdge('z', 's', 2);
g.addEdge('z', 'x', 7);
g.addEdge('t', 'x', 5);
g.addEdge('t', 'y', 8);
g.addEdge('t', 'z', -4);
g.addEdge('x', 't', -2);*/
//负权回路实例
g.addEdge('s', 't', 6);
g.addEdge('s', 'y', 7);
g.addEdge('y', 'z', 9);
g.addEdge('y', 'x', -3);
g.addEdge('y', 's', 1);
g.addEdge('z', 's', 2);
g.addEdge('z', 'x', 7);
g.addEdge('t', 'x', 5);
g.addEdge('t', 'y', -8);
g.addEdge('t', 'z', -4);
g.addEdge('x', 't', -2);
int[] dist = new int[array.length];
int[] parentPath = new int[array.length];
boolean flg = g.bellmanFord('s', dist, parentPath);
if(flg) {
g.printShortPath('s', dist, parentPath);
}else {
System.out.println("存在负权回路");
}
}
public void floydWarShall(int[][] dist, int[][] pPath){
int n = arrayV.length;
for (int i = 0; i < n; i++) {
Arrays.fill(dist[i],Constant.MAX);
Arrays.fill(pPath[i],-1);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if(matrix[i][j] != Constant.MAX){
dist[i][j] = matrix[i][j];
pPath[i][j] = i;
} else {
pPath[i][j] = -1;
}
if(i == j){
dist[i][j] = 0;
pPath[i][j] = -1;
}
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if(dist[i][k] != Constant.MAX && dist[k][j] != Constant.MAX
&& dist[i][k] + dist[k][j] < dist[i][j]){
dist[i][j] = dist[i][k] + dist[k][j];
//更新父节点路径
pPath[i][j] = pPath[k][j];
}
}
}
}
}
public static void main(String[] args) {
//testGraphMinTree();
//testGraphMinTreePrim();
//testGraphDijkstra();
testGraphBellmanFord();
}
}
4900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
