Javascript数据结构——图Graph

GISer_Jing2025-01-01 16:07

当然，让我们深入探讨一下JavaScript中的图数据结构，并列出一些常见的面试题及其代码示例。

图数据结构详解

图（Graph）是一种非线性的数据结构，由节点（也称为顶点）和连接这些节点的边组成。节点可以表示实体（如人、地点、事物等），而边则表示这些实体之间的关系。图可以分为有向图和无向图：

  • 有向图（Directed Graph）：边有方向，即从一个节点指向另一个节点。
  • 无向图（Undirected Graph）：边没有方向，表示两个节点之间的连接。
图的表示方法

  1. 邻接矩阵（Adjacency Matrix）：

    • 使用一个二维数组表示，如果节点i和节点j之间有边，则数组[i][j]为1（或边的权重），否则为0。
    • 优点：查找边是否存在很快（O(1)）。
    • 缺点：空间复杂度较高，尤其是稀疏图（边的数量远小于节点对数量的图）。

  2. 邻接表（Adjacency List）：

    • 使用一个数组或链表数组表示，每个节点对应一个链表，链表中存储该节点连接的所有节点。
    • 优点：空间复杂度较低，适合稀疏图。
    • 缺点：查找边是否存在的时间复杂度较高（O(V)）。
图的遍历

  1. 深度优先搜索（DFS, Depth-First Search）：

    • 使用栈（递归或显式栈）遍历节点，尽可能深入搜索每一个分支。
    • 可以用递归或迭代实现。

  2. 广度优先搜索（BFS, Breadth-First Search）：

    • 使用队列逐层遍历节点。
    • 常用于寻找最短路径（在无权图中）。

常见面试题及其代码

  1. 判断图是否有环（DFS）
javascript 复制代码 
function hasCycle(graph) {
    const visited = new Set();
    const recursionStack = new Set();

    function dfs(node) {
        if (recursionStack.has(node)) return true;
        if (visited.has(node)) return false;

        visited.add(node);
        recursionStack.add(node);

        for (const neighbor of graph[node] || []) {
            if (dfs(neighbor)) return true;
        }

        recursionStack.delete(node);
        return false;
    }

    for (const node in graph) {
        if (dfs(node)) return true;
    }

    return false;
}
  1. 图的深度优先遍历（DFS）
javascript 复制代码 
function dfsTraversal(graph, start, visited = new Set()) {
    if (visited.has(start)) return;
    visited.add(start);
    console.log(start);

    for (const neighbor of graph[start] || []) {
        dfsTraversal(graph, neighbor, visited);
    }
}
  1. 图的广度优先遍历（BFS）
javascript 复制代码 
function bfsTraversal(graph, start) {
    const queue = [start];
    const visited = new Set();

    while (queue.length > 0) {
        const node = queue.shift();
        if (!visited.has(node)) {
            visited.add(node);
            console.log(node);

            for (const neighbor of graph[node] || []) {
                if (!visited.has(neighbor)) {
                    queue.push(neighbor);
                }
            }
        }
    }
}
  1. 计算图的拓扑排序（Kahn's Algorithm）
javascript 复制代码 
function topologicalSort(graph) {
    const inDegree = {};
    const result = [];
    const queue = [];

    // Initialize in-degree map
    for (const node in graph) {
        inDegree[node] = 0;
    }

    // Calculate in-degrees
    for (const node in graph) {
        for (const neighbor of graph[node] || []) {
            inDegree[neighbor] = (inDegree[neighbor] || 0) + 1;
        }
    }

    // Enqueue nodes with zero in-degree
    for (const node in inDegree) {
        if (inDegree[node] === 0) {
            queue.push(node);
        }
    }

    // Process nodes
    while (queue.length > 0) {
        const node = queue.shift();
        result.push(node);

        for (const neighbor of graph[node] || []) {
            inDegree[neighbor]--;
            if (inDegree[neighbor] === 0) {
                queue.push(neighbor);
            }
        }
    }

    // If there was a cycle, not all nodes would be visited
    return result.length === Object.keys(graph).length ? result : [];
}
  1. 计算所有节点对之间的最短路径（Floyd-Warshall Algorithm）
javascript 复制代码 
function floydWarshall(graph) {
    const n = Object.keys(graph).length;
    const dist = JSON.parse(JSON.stringify(graph));

    for (let k = 0; k < n; k++) {
        for (let i = 0; i < n; i++) {
            for (let j = 0; j < n; j++) {
                if (dist[i][k] !== Infinity && dist[k][j] !== Infinity && dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }

    return dist;
}
  1. 检测二分图（Bipartite Graph）
javascript 复制代码 
function isBipartite(graph) {
    const colors = {};
    const queue = [];

    function bfs(node, color) {
        colors[node] = color;
        queue.push(node);

        while (queue.length > 0) {
            const currentNode = queue.shift();
            const currentColor = colors[currentNode];

            for (const neighbor of graph[currentNode] || []) {
                if (!colors[neighbor]) {
                    colors[neighbor] = -currentColor;
                    queue.push(neighbor);
                } else if (colors[neighbor] === currentColor) {
                    return false;
                }
            }
        }

        return true;
    }

    for (const node in graph) {
        if (!colors[node]) {
            if (!bfs(node, 1)) {
                return false;
            }
        }
    }

    return true;
}
  1. 图的最小生成树（Prim's Algorithm）
javascript 复制代码 
function primMST(graph) {
    const n = Object.keys(graph).length;
    const key = new Array(n).fill(Infinity);
    const parent = new Array(n).fill(-1);
    const inMST = new Array(n).fill(false);

    key[0] = 0;
    parent[0] = -1;

    for (let count = 0; count < n - 1; count++) {
        let u = -1, min = Infinity;

        for (let v = 0; v < n; v++) {
            if (!inMST[v] && key[v] < min) {
                u = v;
                min = key[v];
            }
        }

        inMST[u] = true;

        for (const v of graph[u] || []) {
            if (!inMST[v] && graph[u][v] < key[v]) {
                parent[v] = u;
                key[v] = graph[u][v];
            }
        }
    }

    // Construct MST
    const mst = [];
    for (let i = 1; i < n; i++) {
        mst.push([parent[i], i, graph[parent[i]][i]]);
    }

    return mst;
}
}

图的克鲁斯克尔算法（Kruskal's Algorithm）

bash 复制代码 
class UnionFind {
    constructor(n) {
        this.parent = new Array(n);
        for (let i = 0; i < n; i++) {
            this.parent[i] = i;
        }
    }

    find(u) {
        if (this.parent[u] !== u) {
            this.parent[u] = this.find(this.parent[u]); // 路径压缩，使得后续查找更快
        }
        return this.parent[u];
    }

    union(u, v) {
        let rootU = this.find(u);
        let rootV = this.find(v);
        if (rootU !== rootV) {
            this.parent[rootU] = rootV;
        }
    }
}

function kruskalMST(graph) {
    // 图的表示：graph = [ [u, v, weight], ... ]
    let edges = graph.slice().sort((a, b) => a[2] - b[2]); // 排序边
    let n = new Set(); // 存储所有顶点
    for (let edge of edges) {
        n.add(edge[0]);
        n.add(edge[1]);
    }
    let uf = new UnionFind(n.size);
    let mst = [];
    let mstCost = 0;

    for (let edge of edges) {
        let u = edge[0];
        let v = edge[1];
        let weight = edge[2];
        if (uf.find(u) !== uf.find(v)) {
            uf.union(u, v);
            mst.push(edge);
            mstCost += weight;
        }
    }

    return {
        mst: mst,
        cost: mstCost
    };
}

// 示例使用
let graph = [
    [0, 1, 10],
    [0, 2, 6],
    [0, 3, 5],
    [1, 3, 15],
    [2, 3, 4]
];

let result = kruskalMST(graph);
console.log("Edges in MST:", result.mst);
console.log("Total cost of MST:", result.cost);
相关推荐
夫琅禾费米线6 分钟前
React Router 用法概览
前端·javascript·react.js·前端框架
张朋伟——张朋伟8 分钟前
vue 处理二进制文件流下载，封装请求
前端·javascript·vue.js
时间sk26 分钟前
HTML——63.普通按钮和隐藏域
服务器·javascript·html
An_s27 分钟前
canvas+fabric实现时间刻度尺(二)
前端·javascript·vue.js·elementui·fabric
学无止境鸭27 分钟前
更改element-plus的table样式
javascript·vue.js·elementui
橘子海全栈攻城狮36 分钟前
【源码+文档+调试讲解】“健康早知道”微信小程序
开发语言·servlet·微信小程序·小程序·notepad++
爱是小小的癌1 小时前
Java-数据结构-顺序表(ArrayList)
java·开发语言·数据结构
我明天再来学Web渗透1 小时前
【2024年-11月-9日-开源社区openEuler实践记录】OpenAMDC：开启智能边缘计算与系统管控的新征程
开发语言·人工智能·架构·开源·边缘计算·copilot·开源软件
egoist20231 小时前
数据结构之单链表(超详解)
c语言·开发语言·数据结构·笔记·学习·链表·gitee
小_太_阳1 小时前
Scala_【3】运算符
开发语言·scala·intellij-idea
热门推荐
01半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)02新手学习VR全景需要知道的几个问题03HCIA-datacom数通题库和录播视频资料04Coze扣子平台完整体验和实践（附国内和国际版对比）05【漏洞复现】CVE-2015-3337 Arbitrary File Reading06玄机平台应急响应—webshell查杀07【bug记录】清除僵尸进程，释放GPU显存08docker安装启动问题解决排查09优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间10Installing CMake (安装 CMake)