学习笔记——图_图的顶点权重-优快云博客

本文链接：https://blog.youkuaiyun.com/Working_ccll/article/details/140251793

图的定义

图（Graph）是由节点（顶点，Vertex）和边（Edge）组成的一种数据结构。图可以用来表示各种复杂的关系和网络，比如社交网络、交通网络、计算机网络等。

顶点（Vertex）：图中的节点。
边（Edge）：连接两个顶点的线，可以是有向的（从一个顶点到另一个顶点）或无向的（双向的）。
有向图（Directed Graph）：图中的边有方向。
无向图（Undirected Graph）：图中的边没有方向。
权重（Weight）：边上的数值，表示两个顶点之间的距离、成本等。

图的表示方法

图可以用多种方式表示，常见的有邻接矩阵（Adjacency Matrix）和邻接表（Adjacency List）。

邻接矩阵

邻接矩阵是一个二维数组，其中matrix[i][j]表示顶点i和顶点j之间是否有边。对于无向图，矩阵是对称的；对于有向图，矩阵不一定对称。

class Graph {
    private int[][] adjacencyMatrix;
    private int vertices;

    public Graph(int vertices) {
        this.vertices = vertices;
        adjacencyMatrix = new int[vertices][vertices];
    }

    public void addEdge(int source, int destination) {
        adjacencyMatrix[source][destination] = 1;
        adjacencyMatrix[destination][source] = 1; 
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < vertices; i++) {
            for (int j = 0; j < vertices; j++) {
                sb.append(adjacencyMatrix[i][j]).append(" ");
            }
            sb.append("\n");
        }
        return sb.toString();
    }
}

邻接表

邻接表是一个数组，数组的每个元素是一个链表，表示与该顶点相连的所有顶点。

import java.util.LinkedList;

class Graph {
    private int vertices;
    private LinkedList<Integer>[] adjacencyList;

    public Graph(int vertices) {
        this.vertices = vertices;
        adjacencyList = new LinkedList[vertices];
        for (int i = 0; i < vertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }

    public void addEdge(int source, int destination) {
        adjacencyList[source].add(destination);
        adjacencyList[destination].add(source); 
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < vertices; i++) {
            sb.append("Vertex ").append(i).append(": ");
            for (int neighbor : adjacencyList[i]) {
                sb.append(neighbor).append(" ");
            }
            sb.append("\n");
        }
        return sb.toString();
    }
}

图的遍历

图的遍历主要有两种方法：深度优先搜索（DFS）和广度优先搜索（BFS）。

深度优先搜索（DFS）

DFS是一种递归的遍历方法，从一个顶点开始，尽可能深地搜索图的分支。

import java.util.LinkedList;

class Graph {
    private int vertices;
    private LinkedList<Integer>[] adjacencyList;

    public Graph(int vertices) {
        this.vertices = vertices;
        adjacencyList = new LinkedList[vertices];
        for (int i = 0; i < vertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }

    public void addEdge(int source, int destination) {
        adjacencyList[source].add(destination);
        adjacencyList[destination].add(source); 
    }

    private void DFSUtil(int vertex, boolean[] visited) {
        visited[vertex] = true;
        System.out.print(vertex + " ");

        for (int neighbor : adjacencyList[vertex]) {
            if (!visited[neighbor]) {
                DFSUtil(neighbor, visited);
            }
        }
    }

    public void DFS(int startVertex) {
        boolean[] visited = new boolean[vertices];
        DFSUtil(startVertex, visited);
    }
}

广度优先搜索（BFS）

BFS是一种迭代的遍历方法，从一个顶点开始，逐层访问其邻居顶点。

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

class Graph {
    private int vertices;
    private LinkedList<Integer>[] adjacencyList;

    public Graph(int vertices) {
        this.vertices = vertices;
        adjacencyList = new LinkedList[vertices];
        for (int i = 0; i < vertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }

    public void addEdge(int source, int destination) {
        adjacencyList[source].add(destination);
        adjacencyList[destination].add(source); 
    }

    public void BFS(int startVertex) {
        boolean[] visited = new boolean[vertices];
        Queue<Integer> queue = new LinkedList<>();

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

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

            for (int neighbor : adjacencyList[vertex]) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true;
                    queue.add(neighbor);
                }
            }
        }
    }
}