图的定义是什么？JS如何表示图结构

class Graph {
    constructor() {
        this.adjList = new Map(); // 使用Map来存储邻接表，键是顶点，值是Set（方便快速去重和查找）
    }

    addVertex(vertex) {
        if (!this.adjList.has(vertex)) {
            this.adjList.set(vertex, new Set()); // 新增顶点，并初始化一个空的邻居集合
        }
    }

    addEdge(vertex1, vertex2, isDirected = false) {
        // 确保两个顶点都存在
        if (!this.adjList.has(vertex1)) {
            this.addVertex(vertex1);
        }
        if (!this.adjList.has(vertex2)) {
            this.addVertex(vertex2);
        }

        this.adjList.get(vertex1).add(vertex2); // 添加从vertex1到vertex2的边

        if (!isDirected) { // 如果是无向图，需要双向添加
            this.adjList.get(vertex2).add(vertex1);
        }
    }

    removeVertex(vertex) {
        if (!this.adjList.has(vertex)) return;

        // 移除所有指向该顶点的边
        for (let [v, neighbors] of this.adjList.entries()) {
            neighbors.delete(vertex);
        }
        // 移除顶点自身
        this.adjList.delete(vertex);
    }

    removeEdge(vertex1, vertex2, isDirected = false) {
        if (this.adjList.has(vertex1) && this.adjList.get(vertex1).has(vertex2)) {
            this.adjList.get(vertex1).delete(vertex2);
        }
        if (!isDirected && this.adjList.has(vertex2) && this.adjList.get(vertex2).has(vertex1)) {
            this.adjList.get(vertex2).delete(vertex1);
        }
    }

    getNeighbors(vertex) {
        return this.adjList.get(vertex) || new Set();
    }

    printGraph() {
        for (let [vertex, neighbors] of this.adjList.entries()) {
            console.log(`${vertex} -> ${[...neighbors].join(', ')}`);
        }
    }
}

// 示例使用
// const myGraph = new Graph();
// myGraph.addVertex('A');
// myGraph.addVertex('B');
// myGraph.addEdge('A', 'B');
// myGraph.addEdge('B', 'C');
// myGraph.addEdge('A', 'C', true); // 有向边 A -> C
// myGraph.printGraph();
/*
A -> B, C
B -> A, C
C -> B
*/

matrix[i][j]

i

j

// 假设顶点是0到n-1的数字
class AdjacencyMatrixGraph {
    constructor(numVertices) {
        this.numVertices = numVertices;
        this.matrix = Array(numVertices).fill(0).map(() => Array(numVertices).fill(0));
    }

    addEdge(v1, v2, weight = 1, isDirected = false) {
        if (v1 < 0 || v1 >= this.numVertices || v2 < 0 || v2 >= this.numVertices) {
            console.error("Invalid vertex index.");
            return;
        }
        this.matrix[v1][v2] = weight;
        if (!isDirected) {
            this.matrix[v2][v1] = weight;
        }
    }

    hasEdge(v1, v2) {
        if (v1 < 0 || v1 >= this.numVertices || v2 < 0 || v2 >= this.numVertices) {
            return false;
        }
        return this.matrix[v1][v2] !== 0;
    }

    getWeight(v1, v2) {
        if (this.hasEdge(v1, v2)) {
            return this.matrix[v1][v2];
        }
        return null;
    }
    // ... 其他操作，比如移除边、获取邻居等，都围绕这个二维数组展开
}

// const edgeList = [
//     ['A', 'B'],
//     ['B', 'C'],
//     ['A', 'C', { weight: 5, type: 'friend' }] // 也可以存储额外信息
// ];

// 基于前面定义的Graph类
Graph.prototype.bfs = function(startVertex) {
    const visited = new Set();
    const queue = [startVertex]; // 使用数组模拟队列

    visited.add(startVertex);

    while (queue.length > 0) {
        const currentVertex = queue.shift(); // 取出队列头部元素
        console.log(`Visited: ${currentVertex}`); // 访问当前节点

        for (const neighbor of this.getNeighbors(currentVertex)) {
            if (!visited.has(neighbor)) {
                visited.add(neighbor);
                queue.push(neighbor); // 将未访问的邻居加入队列
            }
        }
    }
};

// 示例：
// const bfsGraph = new Graph();
// bfsGraph.addEdge('A', 'B');
// bfsGraph.addEdge('A', 'C');
// bfsGraph.addEdge('B', 'D');
// bfsGraph.addEdge('C', 'E');
// bfsGraph.addEdge('D', 'F');
// bfsGraph.bfs('A'); // 输出顺序可能是 A, B, C, D, E, F

// 基于前面定义的Graph类
Graph.prototype.dfs = function(startVertex) {
    const visited = new Set();
    const _dfs = (vertex) => {
        visited.add(vertex);
        console.log(`Visited: ${vertex}`); // 访问当前节点

        for (const neighbor of this.getNeighbors(vertex)) {
            if (!visited.has(neighbor)) {
                _dfs(neighbor); // 递归访问未访问的邻居
            }
        }
    };

    _dfs(startVertex);
};

// 示例：
// const dfsGraph = new Graph();
// dfsGraph.addEdge('A', 'B');
// dfsGraph.addEdge('A', 'C');
// dfsGraph.addEdge('B', 'D');
// dfsGraph.addEdge('C', 'E');
// dfsGraph.addEdge('D', 'F');
// dfsGraph.dfs('A'); // 输出顺序可能是 A, B, D, F, C, E (取决于邻居的迭代顺序)

visited