【数据结构】图论入门

已于 2024-06-10 21:29:51 修改
阅读量1.4k 收藏 21
点赞数 31
文章标签： 数据结构 图论 java
于 2024-06-07 21:59:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79828182/article/details/139536052
版权

引入

数据的逻辑结构：

  1. 集合：数据元素间除“同属于一个集合”外，无其他关系
  2. 线性结构：一个对一个，例如：线性表、栈、队列
  3. 树形结构：一个对多个，例如：树
  4. 图形结构：多个对多个，例如：图

图的基本概念及术语

图：G = ( V, E )

V：顶点（数据元素）的有穷非空集合

E：边的有穷集合

图的类型定义

无向图：每条边都是无方向的

在这里插入图片描述

有向图：每条弧都是有方向的

在这里插入图片描述

完全图：任意两个点都有一条边相连

  1. 无向完全图：n个结点就有n * (n - 1) / 2 条边
  2. 有向完全图：n个结点就有n * (n - 1) 条边

稀疏图：有很少的边或者弧的图（通常 m 远小于nlog(n)）

稠密图：有较多的边或者弧的图（通常 m 大于nlog(n)）

连通图：在无（有）向图G = (V,{E})中，若对任意两个顶点v、u，都存在v到u的路径，则称G是连通图（强连通图）

图的基本术语

  1. 网：边或者弧带权（有值）的图

  2. 邻接：有边 / 弧相连的两个顶点之间的关系

    • 存在（Vi，Vj），则称 Vi 和 Vj 互为邻接点（无向图）
    • 存在 <Vi，Vj>，则称 Vi 邻接到Vj，Vj 邻接于 Vi（有向图）

  3. 关联（依附）：边 / 弧与顶点之间的关系

    存在（Vi，Vj）/ <Vi，Vj>，则称该边/弧关联与Vi和Vj

  4. 顶点的度：与该顶点相关联的边的数目，记为TD(V)

    在有向图当中，顶点的度等于该顶点的入度与出度之和

    顶点V的入度是以V为终点的有向边的条数

    以上图为例：

    ​ 对于上面的有向图来说，每个结点的度都为2

    ​ 对于上面的无向图来说，每个结点的度都为3，但是不同结点的入度、出度不一样（V3入度为1，出度为2）

  5. 路径：连接的边构成的顶点序列

  6. 路径长度：路径上边/弧的数目/权值之和

  7. 回路（环）：第一个顶点和最后一个顶点相同的路径

  8. 简单路径：除路径起点和终点可以相同之外，其余顶点均不相同的路径

  9. 简单回路（简单环）：除路径起点和终点相同之外，其余顶点均不相同的路径

  10. 子图：设有两个图G = (V,{E})，G1 = (V1,{E1})，若V1属于V并且E1属于E，则称G1是G的子图

  11. 连通分量（强连通分量）：无（有）向图的极大连通子图称为G的连通分量（强连通分量）

    • 极大连通子图：该子图是G连通子图，将G的任何不在该子图的顶点加入，此图不再连续
    • 极小连通子图：该子图是G的连通子图，在该子图中删除任何一条边，此子图不再连续

图的存储结构

数组（邻接矩阵）表示法

概述

建立一个顶点表（记录各个顶点信息）和一个邻接矩阵（表示各个顶点之间的关系）

  1. 设图A = (V,E)有n个顶点，则顶点表Vext[n]表示为

    i01…n-1
    Vext[i]V1V2…Vn

  2. 图的邻接矩阵是一个二维数组A.arcs[n][n],定义为：

    当存在<i,j>或者( i,j )属于图中的边或者弧，我们就将A.arcs[i][j]赋值为1，否则为0

举例

无向图

在这里插入图片描述

具体形况根据顶点的值去建立顶点表

邻接矩阵：

V1V2V3V4V5
V101010
V210101
V301011
V410100
V501100

特点：

  1. 无向图的邻接矩阵是对称的
  2. 顶点i的度 = 第i行（列）中1的个数
  3. 完全图的邻接矩阵中，对角元素为0，其余为1

代码演示见下面遍历部分

有向图

在这里插入图片描述

邻接矩阵：

v1v2v3v4
v10110
v20000
v30001
v41000

特点：

  1. 有向图的邻接矩阵可能是不对称的

  2. 顶点的出度 = 第i行元素之和

    顶点的入度 = 第i列元素之和

    顶点的度 = 出度 + 入度

网的邻接矩阵就是将1用权值替换

代码演示见下面遍历部分

优缺点

优点：

  1. 直观，简单，好理解
  2. 方便检查任意一对顶点间是否存在边
  3. 方便找任意顶点的所有邻接点
  4. 方便计算出任意顶点的度

缺点：

  1. 不利于增加和删除顶点
  2. 浪费空间：存稀疏图，有大量无效元素
  3. 浪费时间：统计稀疏图中共有多少条边

邻接表

顶点：按编号顺序将顶点数据存储在一维数组中

关联同一顶点的边（以顶点为尾的弧）：用线性链表存储

举例

仍以上图为例

无向图：

在这里插入图片描述

特点：

  1. 邻接表不唯一
  2. 若无向图中有n个顶点e条边，则其邻接表需n个头结点和2e个表结点，适宜存储稀疏图
  3. 无向图中顶点vi的度为第i个单链表中的结点数

代码演示见下面遍历部分

有向图：

在这里插入图片描述

特点：

  1. 顶点vi的出度为第i个单链表中的结点个数
  2. 顶点vi的入度为整个单链表中邻接点域值是i-1的结点个数

代码演示见下面遍历部分

邻接矩阵与邻接表的关系:

1.联系：邻接表中每个链表对应于邻接矩阵中的每一行，链表中结点个数等于一行中非零元素的个数

2.区别：

a.对于任意确定的无向图，邻接矩阵是唯一的(行列号与顶点编号一致)，但邻接表不唯一（连接次序与顶点编号无关）
b.邻接矩阵的空间复杂度为O(n^2)，而连接表的空间复杂度为O(n+e)

图的遍历

定义：从已给的连通图中某一顶点出发，沿着一些边访问图中所有的顶点，且每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算

实质：找每个顶点的邻接点的过程

问题：由图的特点，图中可能出现回路，且图的任一顶点都可能与其他结点相遇，在访问完某个顶点之后可能会沿着某些边又回到了曾经访问过的顶点，怎么避免重复访问？

解决思路：设置辅助数组a[n]，用来标记每个被访问过的顶点，初始状态都为0，当顶点i被访问，改a[i]为1，防止被多次访问

深度优先搜索（DFS）

方法：

  1. 在访问图中某一起始顶点v后，由v出发，访问它的任一邻接顶点w1
  2. 再由w1出发访问与w1邻接，但还未被访问过的顶点w2
  3. 然后再从w2出发进行类似的访问…
  4. 如此进行下去，直至到达所有的邻接顶点都被访问过的顶点u为止
  5. 接着退回一步退到前一次刚访问过的顶点，看是否还有其他没有被访问的邻接顶点
  6. 如果有则访问此顶点，之后再从此顶点出发，进行与之前类似的访问
  7. 如果没有就再退回一步进行搜索，重复上述过程，直到连通图中所有顶点都被访问过为止

注意：

  1. 稠密图适于在邻接矩阵上进行深度遍历
  2. 稀疏图适于在连接表上进行深度遍历

对于邻接矩阵的代码演示：

public class GraphAdjacencyMatrix {
    private int V; // 顶点的数量
    private int[][] matrix; // 邻接矩阵
    private boolean[] visited;
    // 构造函数
    public GraphAdjacencyMatrix(int v) {
        V = v;
        matrix = new int[v][v];
        visited = new boolean[v];
        for (int i = 0; i < v; i++) {
            visited[i] = false;
        }
    }

    // 添加边
    public void addEdge(int v, int w, int weight) {
        matrix[v][w] = weight; // 因为是无向图，所以需要添加两个方向的边
        matrix[w][v] = weight;
    }

    //深度优先遍历
    private void DFS(int v) {
        visited[v] = true;
        System.out.print(v + " ");

        for (int i = 0; i < V; i++) {
            if (matrix[v][i] == 1 && !visited[i]) {
                DFS(i);
            }
        }
    }

    // 遍历所有顶点（如果顶点未访问，则进行DFS）
    public void DFSTraversal() {
        for (int i = 0; i < V; i++) {
            if (!visited[i]) {
                DFS(i); // 从顶点i开始DFS
            }
        }
    }

    // 打印图
    public void printGraph() {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                if (matrix[i][j] == 0) {
                    System.out.print("0 ");
                } else {
                    System.out.print(matrix[i][j] + " ");
                }
            }
            System.out.println();
        }
    }
}

public class linjiejuzhen {
    public static void main(String[] args) {
        GraphAdjacencyMatrix graph = new GraphAdjacencyMatrix(4);

        graph.addEdge(0, 1, 10); // 添加边 0-1 权重为 10
        graph.addEdge(0, 2, 6);
        graph.addEdge(1, 2, 4);
        graph.addEdge(2, 3, 1);

        System.out.println("Adjacency Matrix:");
        graph.printGraph();
        System.out.println("Depth First Traversal starting from vertex 0: ");
        graph.DFSTraversal(); //0 1 2 3
    }
}

Adjacency Matrix:
0 10 6 0 
10 0 4 0 
6 4 0 1 
0 0 1 0 
Depth First Traversal starting from vertex 0: 
0 1 2 3

对于邻接表代码演示：

import java.util.Iterator;
import java.util.LinkedList;

public class DirectedGraphAdjacencyList {
    private int V; // 顶点的数量
    private LinkedList<Integer> adj[];
    private boolean visited[]; // 邻接表

    // 构造函数
    public DirectedGraphAdjacencyList(int v) {
        V = v;
        adj = new LinkedList[v];
        visited = new boolean[v];
        for (int i = 0; i < v; i++) {
            adj[i] = new LinkedList<>();
            visited[i] = false;
        }
    }

    // 添加边
    public void addEdge(int v, int w) {
        adj[v].add(w); // 添加从顶点v到顶点w的有向边
    }

    // 打印图
    public void printGraph() {
        for (int i = 0; i < V; i++) {
            System.out.print("Vertex " + i + ":");
            Iterator<Integer> it = adj[i].iterator();
            while (it.hasNext()) {
                System.out.print(" -> " + it.next());
            }
            System.out.println();
        }
    }

    private void DFS(int v) {
        visited[v] = true;
        System.out.print(v + " ");

        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext()) {
            int n = i.next();
            if (!visited[n]) {
                DFS(n); // 递归访问未访问的邻接顶点
            }
        }
    }

    // 遍历所有顶点执行DFS
    public void DFSTraversal() {
        for (int i = 0; i < V; i++) {
            if (!visited[i]) {
                DFS(i); // 从顶点i开始DFS
            }
        }
    }
}

public class DirectedGraphAdjacency {
    public static void main(String[] args) {
        DirectedGraphAdjacencyList graph = new DirectedGraphAdjacencyList(6);

        // 添加有向边
        graph.addEdge(5, 0);
        graph.addEdge(5, 3);
        graph.addEdge(4, 0);
        graph.addEdge(4, 1);
        graph.addEdge(2, 3);
        graph.addEdge(3, 1);
        graph.addEdge(1, 3);

        System.out.println("Adjacency List Representation of Directed Graph:");
        graph.printGraph();
        System.out.println("Depth First Traversal starting from vertex 0: ");
        graph.DFSTraversal(); //0 1 3 2 4 5
    }
}

Adjacency List Representation of Directed Graph:
Vertex 0:
Vertex 1: -> 3
Vertex 2: -> 3
Vertex 3: -> 1
Vertex 4: -> 0 -> 1
Vertex 5: -> 0 -> 3
Depth First Traversal starting from vertex 0: 
0 1 3 2 4 5

广度优先搜索（BFS）

方法：

从图的某一结点出发，首先依次访问该结点的所有邻接结点 Vi1、Vi2……Vin，再按这些顶点被访问的先后次序依次访问与他们相邻接的所有未被访问的顶点。重复此过程，直至所有顶点均被访问为止

对于邻接矩阵的代码演示

import java.util.LinkedList;
import java.util.Queue;

public class DirectedGraphAdjacencyMatrix {
    private int V; // 顶点的数量
    private int[][] matrix; // 邻接矩阵
    private boolean[] visited;

    // 构造函数
    public DirectedGraphAdjacencyMatrix(int v) {
        V = v;
        matrix = new int[v][v];
        visited = new boolean[v];
        // 初始化矩阵，所有元素都设置为0，表示没有边
        for (int i = 0; i < v; i++) {
            for (int j = 0; j < v; j++) {
                matrix[i][j] = 0;
            }
            visited[i] = false;
        }
    }

    // 添加边
    public void addEdge(int v, int w, int weight) {
        matrix[v][w] = weight; // 只在矩阵的对应位置添加边的权重
    }

    // 打印图
    public void printGraph() {
        for (int i = 0; i < V; i++) {
            for (int j = 0; j < V; j++) {
                if (matrix[i][j] == 0) {
                    System.out.print(" 0 ");
                } else {
                    System.out.print(" " + matrix[i][j] + " ");
                }
            }
            System.out.println();
        }
    }
    //广度优先搜索
    public void BFS(int start) {
        Queue<Integer> queue = new LinkedList<>();
        visited[start] = true; // 标记起始顶点为已访问
        queue.add(start); // 将起始顶点添加到队列中

        while (!queue.isEmpty()) {
            int v = queue.poll(); // 从队列中取出一个顶点
            System.out.print(v + " ");

            for (int i = 0; i < V; i++) {
                if (matrix[v][i] != 0 && !visited[i]) {
                    visited[i] = true; // 标记邻接顶点为已访问
                    queue.add(i); // 将邻接顶点添加到队列中
                }
            }
        }
    }
}

public class linjiejuzhenYou {
    public static void main(String[] args) {
        DirectedGraphAdjacencyMatrix graph = new DirectedGraphAdjacencyMatrix(4);

        graph.addEdge(0, 1, 10); // 添加有向边 0->1 权重为 10
        graph.addEdge(0, 2, 6);
        graph.addEdge(1, 2, 4);
        graph.addEdge(1, 3, 1);
        graph.addEdge(2, 3, 7);

        System.out.println("Directed Adjacency Matrix:");
        graph.printGraph();
        System.out.println("Breadth First Traversal starting from vertex 0: ");
        graph.BFS(0); //0 1 2 3
    }
}

Directed Adjacency Matrix:
 0  10  6  0 
 0  0  4  1 
 0  0  0  7 
 0  0  0  0 
Breadth First Traversal starting from vertex 0: 
0 1 2 3

对于邻接表的代码演示

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class UndirectedGraphAdjacencyList {
    private int V; // 顶点的数量
    private LinkedList<Integer> adj[]; // 邻接表
    private boolean[] visited;

    // 构造函数
    public UndirectedGraphAdjacencyList(int v) {
        V = v;
        visited = new boolean[V];
        adj = new LinkedList[v];
        for (int i = 0; i < v; i++) {
            adj[i] = new LinkedList<>();
            visited[i] = false;
        }
    }

    // 添加边
    public void addEdge(int v, int w) {
        adj[v].add(w); // 添加从v到w的边
        adj[w].add(v); // 因为是无向图，所以需要添加从w到v的边
    }

    // 打印图
    public void printGraph() {
        for (int i = 0; i < V; i++) {
            System.out.print("Vertex " + i + ":");
            Iterator<Integer> it = adj[i].iterator();
            while (it.hasNext()) {
                System.out.print(" -> " + it.next());
            }
            System.out.println();
        }
    }

    public void BFS(int start) {
        Queue<Integer> queue = new LinkedList<>();
        visited[start] = true; // 标记起始顶点为已访问
        queue.add(start); // 将起始顶点添加到队列中

        while (!queue.isEmpty()) {
            int v = queue.poll(); // 从队列中取出一个顶点
            System.out.print(v + " ");

            Iterator<Integer> i = adj[v].listIterator();
            while (i.hasNext()) {
                int n = i.next();
                if (!visited[n]) {
                    visited[n] = true; // 标记邻接顶点为已访问
                    queue.add(n); // 将邻接顶点添加到队列中
                }
            }
        }
    }
}

public class UndirectedGraphAdjacency {
    public static void main(String[] args) {
        UndirectedGraphAdjacencyList graph = new UndirectedGraphAdjacencyList(4);

        graph.addEdge(0, 1); // 添加边 0-1
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(2, 3);

        System.out.println("Adjacency List Representation of Undirected Graph:");
        graph.printGraph();
        System.out.println("Breadth First Traversal starting from vertex 0: ");
        graph.BFS(0); //0 1 2 3
    }
}

Adjacency List Representation of Undirected Graph:
Vertex 0: -> 1 -> 2
Vertex 1: -> 0 -> 2
Vertex 2: -> 0 -> 1 -> 3
Vertex 3: -> 2
Breadth First Traversal starting from vertex 0: 
0 1 2 3

二者搜索的算法分析

时间复杂度：

邻接矩阵：
对于邻接矩阵表示的图，时间复杂度主要受两个因素影响：

  1. 矩阵大小：邻接矩阵的大小为 𝑉×𝑉，其中 V 是顶点的数量。

  2. 遍历矩阵：你需要遍历整个邻接矩阵来检查每个顶点的所有邻接点。

因此，对于邻接矩阵表示的图，时间复杂度为 𝑂(𝑉^2)，这是因为你需要检查 V 个顶点，每个顶点可能与其他 V 个顶点相连。

邻接表：
对于邻接表表示的图，时间复杂度分析如下：

  1. 顶点数量：图有 V 个顶点。

  2. 边的数量：图有 E 条边。

  3. 访问邻接表：你访问每个顶点的邻接表，每个邻接表包含与该顶点直接相连的顶点。

  4. 队列操作：使用队列（栈）来存储待访问的顶点，每次从队列（栈）中取出一个顶点，并将其所有未访问的邻接顶点加入队列（栈）。

因此，对于邻接表表示的图，时间复杂度为 O(V+E)。这是因为你访问了所有 V 个顶点，并且每个顶点的邻接表（即所有边）也被访问了一次。

空间复杂度：空间复杂度相同，都是O(n)

为实习准备的数据结构（11）-- 图论算法 集锦(1)
2401_83817343的博客
04-19 294
图是由顶点的有穷非空集合和顶点之间边的集合组成， 通常表示为: G（V，E）， 其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。这种叫做无向图，里面的边叫做无向边。图有各种形状和大小。边可以有权重（weight），即每一条边会被分配一个正数或者负数值。考虑一个代表航线的图。各个城市就是顶点，航线就是边。那么边的权重可以是飞行时间，或者机票价格。边可以是有方向的。在上面提到的例子中，边是没有方向的。有方向的边意味着是单方面的关系。事实证明图是一种有用的数据结构。
数据结构之图论
05-24
数据结构之图论，130多页的PPT，详细讲解了图的定义，算法等，充分了解图的好资料
数据结构_图论
xiaoyangsavvy的专栏
09-06 402
图的概念 图是一种非线性的数据结构,一个图中有两类东西，一种是结点，一种是边.我们用V这个集合来表示节点（vertex），还需要另一个集合来存储所有的边，我们用E来表示(Edge)，那么一个图就可以表示为：G=(V,E); 带箭头的称为有向图,否则称为无向图. 如果一个图的任意两个结点之间有且只有一条边，则称此图为无向完全图，若任意两个结点之间有且只有方向相反的两条边，则称为有向完全图.度是针对...
【数据结构】图论
sight_720的博客
07-27 995
图论初步
程序员的数学4：图论入门.pptx
10-14
在编程中，我们通常会使用节点和边来表示数据结构，例如树、图等。 图论的基本概念包括图、节点、边、度数等。图可以分为有向图和无向图两种，边的两端连接到两个节点。在有向图中，边的两端连接到两个节点，但方向...
数据结构从入门到精通-队列
最新发布
03-10
4. 广度优先搜索（BFS）：在图论和算法中，队列是实现广度优先搜索的关键数据结构。 在C语言中实现队列操作的具体代码涉及很多细节，包括初始化队列、判断队列状态、入队、出队等函数的编写。这些函数需要考虑边界...
图论入门_谢兴宇.pdf
09-14
图论入门 图论是计算机科学和数学的一个重要分支，它研究图形结构的性质和算法。图论的应用非常广泛，包括社交网络、交通网络、数据挖掘、机器学习等领域。 图论的基本概念包括： 1. 图的定义：图是一种非线性...
C++关于图论入门的课件
09-15
图论是计算机科学中的一个重要分支，它研究的对象是图，一种用于表示对象间关系的数据结构。在C++中，理解图论有助于解决许多复杂问题，如路径搜索、网络流、最短路径等。以下是对图论及其在C++中实现的基础知识的...
scoi刷题记录（2019/04/07）
weixin_30487701的博客
04-07 117
scoi2005 繁忙的都市 扫雷 互不侵犯 scoi2006 zh_tree scoi2007 排列 scoi2009 最长距离 生日礼物 scoi2010 幸运数字 scoi2011 糖果 scoi2012 喵星球上的点名 转载于:https://www.cnblogs.com/Achensy/p/10664044.html...
数据结构 第6章 图
博客搬往 http://begtostudy.cnblogs.com
09-20 1438
第6章 图 本章中介绍下列主要内容：　　 1.图的定义　　 2.图的存储结构　　 3.图的遍历操作　　 4.图的几个典型应用问题课时分配：        1、2两个学时，3两个学时，4四个学时,上机两个学时重点、难点：        图的遍历操作、典型应用问题  第一节 图的定义  1．定义    图是由结点的有穷集合V和边的集合E组成。其中，为了与树形结构加以区别，在图结构中常常将结点称为顶点，边是顶点的有序偶对，若两个顶点之间存在一条边，就表
数据结构——图论
rookie636的博客
11-30 521
图论A - 数据结构实验之图论一：基于邻接矩阵的广度优先搜索遍历题目代码B - 数据结构实验之图论二：图的深度遍历题目代码C - 数据结构实验之图论三：判断可达性题目代码D - 数据结构实验之图论四：迷宫探索题目代码E - 数据结构实验之图论五：从起始点到目标点的最短步数（BFS）题目代码F - 数据结构实验之图论六：村村通公路题目代码G - 数据结构实验之图论七：驴友计划题目代码H - 数据结构实验之图论八：欧拉回路题目代码I - 数据结构实验之图论九：最小生成树题目代码J - 数据结构实验之图论十：判断
数据结构 图论
hello world
09-17 1321
0.引入 在生活中，随处可见与图相关的应用： 地图：在使用地图中，经常会想知道“从xx到xx的最短路线”这样的问题，要回答这些问题，需要把地图抽象成一个图(Graph)，十字路口就是顶点，公路就是边。 互联网： 整个互联网其实就是一张图，它的顶点为网页，边为超链接，图论可以帮我们在网络上定位信息。 任务调度：当一些任务拥有优先级限制且需要满足前置条件时，如何在满足条件的情况下用最少的时间完成...
关于『数据结构』：图论
自强不息，厚德载物
08-26 596
  拥抱大只图论。   诸位怎么都如此能肝，md 就我图论还没写完。   (投放My blogs csdn & 博客园😃。)  举个🌰（栗子）：  图是由若干给定的顶点（例如 V1,V2V1, V2V1,V2）及连接两顶点的边（例如 (V1,V2),(V4,V5)(V1, V2),(V4, V5)(V1,V2),(V4,V5)）所构成的图形。   这种图形通常用来描述某些具体事物之间的某种特定关系。顶点用于代表事物，连接两顶点的边则用于表示具体事物间的关系。   若一张图的边数远小于其点数的平方，那么它..
数据结构课程：图论
算法人生
02-12 498
图基础： 定义：描述事物之间的关系。 包括：节点集V={V1,V2......,Vn}，边集合E={e1，e2，......,em},其中ei=（vi，vi‘） G=&lt;V,E&gt; 包括有向图和无向图 空间复杂度一般为：O（n+m）或O(n2） 主要应用包括：邻接矩阵，邻接表 图的存储结构：  1、邻接矩阵表示法：  如果 第 1个点和第 3个点 相连则 matrix...
数据结构与算法——图论
偷得浮生半日闲
08-23 923
一、图的概念 图形由顶点/节点和连接这些顶点的边/线组成。 图可以是无向的（意味着在与每个双向边相关联的两个顶点之间没有区别）或者可以指向图（意味着其边缘从一个顶点指向另一个顶点但不一定在另一个方向上）。 可以对图形进行加权（通过向每个边缘分配权重，其表示与该连接相关联的数值）或者图形可以是未加权的（所有边缘具有单位权重1或者所有边缘具有相同的恒定权重） 图的可视化 顶点（vertex） ...
数据结构学习笔记：图论
weixin_42479032的博客
02-21 403
前言   图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。   图论是一种表示 “多对多” 的关系   图是由顶点和边组成的：(可以无边，但至少包含一个顶点) 一组顶点：通常用 V(vertex) 表示顶点集合 一组边：通常用 E(edge) 表示边的集合 图可以分为有向图和无向图，在图中： (v, w) 表示无向边，即 v
C语言数据结构入门：术语解析与图论实例
数据结构习题集答案_C语言版 本习题集针对数据结构的基础概念进行了详细的阐述。首先，章节1.1介绍了几个核心术语： 1. **数据**：在计算机科学中，数据是对客观事物符号的表示，指的是能够输入计算机并被程序处理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值