数据结构与算法：图形数据结构

星光闪闪k

于 2024-02-24 15:02:05 发布

阅读量1.1k

点赞数 27

分类专栏：数据结构与算法 Java 文章标签：数据结构后端架构 java

本文链接：https://blog.csdn.net/qq_35763697/article/details/136271868

版权

Java 同时被 2 个专栏收录

55 篇文章 0 订阅

订阅专栏

数据结构与算法

5 篇文章 0 订阅

订阅专栏

1. 图的基本概念和表示方法

图是一种由节点和边组成的非线性数据结构，用于描述事物之间的关系。在计算机科学中，图是一种十分重要的数据结构，广泛应用于各种领域，如网络分析、路径规划等。本节将介绍图的基本概念和两种常见的表示方法：邻接矩阵和邻接表。

1.1 图的定义

在图论中，图（Graph）是由顶点集合和边集合组成的一种数学模型。图可以表示任意的关系，例如社交网络中的用户和好友之间的关系，地图上的城市和道路之间的连接关系等。

图可以分为有向图和无向图两种类型。在有向图中，边是有方向的，表示从一个顶点到另一个顶点的箭头。而在无向图中，边是无方向的，表示两个顶点之间的双向关系。

1.2 图的表示方法

邻接矩阵

邻接矩阵是使用二维数组表示图的连接关系的一种方式。矩阵的行和列分别对应图中的顶点，矩阵中的元素表示顶点之间是否存在边。如果图是无向图，则矩阵是对称的；如果是有向图，则不一定对称。

让我们通过一个示例来说明邻接矩阵的表示方法：

// 一个简单的无向图的邻接矩阵表示
int[][] adjacencyMatrix = {
    {0, 1, 1, 0, 0},  // 顶点 0 与顶点 1、2 相连
    {1, 0, 0, 1, 0},  // 顶点 1 与顶点 0、3 相连
    {1, 0, 0, 1, 1},  // 顶点 2 与顶点 0、3、4 相连
    {0, 1, 1, 0, 0},  // 顶点 3 与顶点 1、2 相连
    {0, 0, 1, 0, 0}   // 顶点 4 与顶点 2 相连
};

在上面的示例中，数组中的值表示相应顶点之间是否有边相连。值为 1 表示相连，值为 0 表示不相连。

邻接表

邻接表是使用链表或数组的方式表示图的连接关系的一种方式。对于每个顶点，我们可以使用一个列表来存储与其相邻的顶点。这种表示方法适用于稀疏图，因为它节省了空间。

让我们通过一个示例来说明邻接表的表示方法：

import java.util.*;

// 图的邻接表表示
class Graph {
    int V; // 顶点数
    LinkedList<Integer>[] adjacencyList; // 邻接表

    // 构造函数
    Graph(int v) {
        V = v;
        adjacencyList = new LinkedList[v];
        for (int i = 0; i < v; ++i) {
            adjacencyList[i] = new LinkedList();
        }
    }

    // 添加边
    void addEdge(int v, int w) {
        adjacencyList[v].add(w);
        adjacencyList[w].add(v); // 如果是有向图，则去掉此行
    }
}

在上面的示例中，我们使用了一个数组来存储邻接表，数组中的每个元素是一个链表，存储与该顶点相邻的顶点。通过添加边的操作，我们可以构建出图的邻接表表示。

2. 图的遍历算法

图的遍历算法是图算法中的基础部分，用于访问图中的所有节点。常用的图遍历算法包括深度优先搜索（DFS）和广度优先搜索（BFS）。本节将详细介绍这两种算法的原理、实现方式以及在图中的应用场景。

2.1 深度优先搜索（DFS）

深度优先搜索是一种用于遍历或搜索图或树的算法。它从起始顶点开始，沿着一条路径尽可能深地搜索，直到到达最深处，然后回溯并继续搜索其他路径。DFS可以使用递归或栈来实现。

让我们通过一个示例来说明DFS算法的基本原理和实现方式：

import java.util.*;

// 图的深度优先搜索
class Graph {
    private int V; // 顶点数
    private LinkedList<Integer>[] adjacencyList; // 邻接表

    // 构造函数
    Graph(int v) {
        V = v;
        adjacencyList = new LinkedList[v];
        for (int i = 0; i < v; ++i) {
            adjacencyList[i] = new LinkedList();
        }
    }

    // 添加边
    void addEdge(int v, int w) {
        adjacencyList[v].add(w);
    }

    // 深度优先搜索算法
    void DFSUtil(int v, boolean[] visited) {
        visited[v] = true;
        System.out.print(v + " ");

        Iterator<Integer> iterator = adjacencyList[v].listIterator();
        while (iterator.hasNext()) {
            int n = iterator.next();
            if (!visited[n]) {
                DFSUtil(n, visited);
            }
        }
    }

    // 对外接口，用于调用深度优先搜索算法
    void DFS(int v) {
        boolean[] visited = new boolean[V];
        DFSUtil(v, visited);
    }
}

// 示例代码
public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph(4);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(2, 0);
        graph.addEdge(2, 3);
        graph.addEdge(3, 3);

        System.out.println("深度优先遍历结果：");
        graph.DFS(2);
    }
}

在上面的示例中，我们定义了一个Graph类来表示图，并实现了深度优先搜索算法。通过调用DFS方法，我们可以从指定的起始顶点开始进行深度优先搜索，并输出遍历结果。

2.2 广度优先搜索（BFS）

广度优先搜索是一种用于遍历或搜索图或树的算法。它从起始顶点开始，逐层遍历图的所有节点，直到找到目标节点或遍历完整个图。BFS可以使用队列来实现。

让我们通过一个示例来说明BFS算法的基本原理和实现方式：

import java.util.*;

// 图的广度优先搜索
class Graph {
    private int V; // 顶点数
    private LinkedList<Integer>[] adjacencyList; // 邻接表

    // 构造函数
    Graph(int v) {
        V = v;
        adjacencyList = new LinkedList[v];
        for (int i = 0; i < v; ++i) {
            adjacencyList[i] = new LinkedList();
        }
    }

    // 添加边
    void addEdge(int v, int w) {
        adjacencyList[v].add(w);
    }

    // 广度优先搜索算法
    void BFS(int s) {
        boolean[] visited = new boolean[V];
        LinkedList<Integer> queue = new LinkedList<>();

        visited[s] = true;
        queue.add(s);

        while (!queue.isEmpty()) {
            s = queue.poll();
            System.out.print(s + " ");

            Iterator<Integer> iterator = adjacencyList[s].listIterator();
            while (iterator.hasNext()) {
                int n = iterator.next();
                if (!visited[n]) {
                    visited[n] = true;
                    queue.add(n);
                }
            }
        }
    }
}

// 示例代码
public class Main {
    public static void main(String[] args) {
        Graph graph = new Graph(4);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(2, 0);
        graph.addEdge(2, 3);
        graph.addEdge(3, 3);

        System.out.println("广度优先遍历结果：");
        graph.BFS(2);
    }
}

在上面的示例中，我们同样定义了一个Graph类来表示图，并实现了广度优先搜索算法。通过调用BFS方法，我们可以从指定的起始顶点开始进行广度优先搜索，并输出遍历结果。

3. 图的应用场景和算法

图作为一种非线性数据结构，在现实生活和计算机科学中有着广泛的应用。本节将介绍图在实际场景中的应用，并探讨一些常见的图算法。

3.1 最短路径算法

最短路径算法用于寻找图中两个顶点之间的最短路径，其在网络路由、地图导航等领域有着重要的应用。常见的最短路径算法包括Dijkstra算法和Bellman-Ford算法。

Dijkstra算法：该算法用于计算从起始顶点到图中所有其他顶点的最短路径。它采用贪心策略，每次选择当前最短路径的顶点进行扩展，直到找到目标顶点或者遍历完整个图。Dijkstra算法适用于没有负权边的图。
Bellman-Ford算法：与Dijkstra算法不同，Bellman-Ford算法可以处理图中存在负权边的情况。该算法采用动态规划的思想，通过多次迭代来不断更新顶点的最短路径估计值，直到收敛为止。

3.2 最小生成树算法

最小生成树算法用于寻找连接图中所有顶点的最小连通子图，其在网络设计、电路布线等领域有着重要的应用。常见的最小生成树算法包括Prim算法和Kruskal算法。

Prim算法：该算法从一个初始顶点开始，逐步添加边，直到所有顶点都被包含在生成树中。Prim算法使用贪心策略，每次选择当前与生成树相邻且权值最小的边进行扩展。
Kruskal算法：与Prim算法不同，Kruskal算法是一种基于边的贪心算法。该算法先将所有边按权值从小到大排序，然后依次选择权值最小的边，如果该边的两个端点不在同一个连通分量中，则将其加入最小生成树。