需求：自己写一套简单导航逻辑。1.导航路径由一个个节点组成，每个节点自定义可到达哪几个节点，根据这样一个网络写出一套算法实时获取最近节点，然后计算出所有可能到达终点的方案中最近的方案，最后返回出最近方案的数组

好的，那么我可以为您提供一种基于Dijkstra算法的解决方案，您可以参考一下：

首先，我们需要定义节点对象，每个节点包含如下属性：

- id：节点ID
- name：节点名称
- neighbors: 可到达的邻居节点数组，每个邻居节点包含邻居节点ID、到邻居节点的距离

示例代码如下：

class Node {
  constructor(id, name, neighbors) {
    this.id = id;
    this.name = name;
    this.neighbors = neighbors;
  }
}

接下来，我们需要实现一个算法类，包含以下方法：

- addNode(node)：添加一个节点对象到算法中
- getShortestPath(startId, endId)：获取从起点到终点的最近路径，返回一个节点ID数组

示例代码如下：

class NavigationAlgorithm {
  constructor() {
    this.nodes = new Map();
  }

  // 添加节点
  addNode(node) {
    this.nodes.set(node.id, node);
  }

  // 获取最近路径
  getShortestPath(startId, endId) {
    const distances = new Map(); // 距离Map，记录每个节点到起点的距离
    const visitedNodes = new Set(); // 访问过的节点集合
    const previousNodes = new Map(); // 前置节点Map，记录每个节点的前置节点
    const queue = []; // 待访问节点队列

    // 初始化距离Map和待访问节点队列
    distances.set(startId, 0);
    queue.push({ nodeId: startId, distance: 0 });

    while (queue.length > 0) {
      // 从队列中取出距离最小的节点
      const { nodeId, distance } = queue.shift();

      // 如果当前节点已经访问过，则跳过
      if (visitedNodes.has(nodeId)) {
        continue;
      }

      // 将当前节点标记为已访问
      visitedNodes.add(nodeId);

      // 如果当前节点是终点，则停止搜索
      if (nodeId === endId) {
        break;
      }

      // 遍历当前节点的邻居节点
      const node = this.nodes.get(nodeId);
      for (const neighbor of node.neighbors) {
        const neighborNode = this.nodes.get(neighbor.id);
        const neighborDistance = distances.get(nodeId) + neighbor.distance;

        // 如果邻居节点到当前节点的距离更短，则更新距离Map和前置节点Map
        if (!distances.has(neighbor.id) || neighborDistance < distances.get(neighbor.id)) {
          distances.set(neighbor.id, neighborDistance);
          previousNodes.set(neighbor.id, nodeId);
        }

        // 将邻居节点加入待访问节点队列
        queue.push({ nodeId: neighbor.id, distance: neighborDistance });
      }

      // 将待访问节点队列按照距离从小到大排序
      queue.sort((a, b) => a.distance - b.distance);
    }

    // 构建最近路径
    const path = [];
    let currentNodeId = endId;
    while (previousNodes.has(currentNodeId)) {
      path.unshift(currentNodeId);
      currentNodeId = previousNodes.get(currentNodeId);
    }
    path.unshift(startId);

    return path;
  }
}

使用示例：

// 创建节点对象
const node1 = new Node(1, 'Node 1', [
  { id: 2, distance: 10 },
  { id: 3, distance: 5 },
]);
const node2 = new Node(2, 'Node 2', [
  { id: 1, distance: 10 },
  { id: 4, distance: 20 },
]);
const node3 = new Node(3, 'Node 3', [
  { id: 1, distance: 5 },
  { id: 4, distance: 15 },
]);
const node4 = new Node(4, 'Node 4', [
  { id: 2, distance: 20 },
  { id: 3, distance: 15 },
  { id: 5, distance: 10 },
]);
const node5 = new Node(5, 'Node 5', [
  { id: 4, distance: 10 },
]);

// 创建算法对象
const algorithm = new NavigationAlgorithm();
algorithm.addNode(node1);
algorithm.addNode(node2);
algorithm.addNode(node3);
algorithm.addNode(node4);
algorithm.addNode(node5);

// 获取最近路径
const shortestPath = algorithm.getShortestPath(1, 5);
console.log(shortestPath); // [1, 3, 4, 5]

在上述示例中，我们创建了一个包含5个节点的导航网络，然后使用算法类获取从节点1到节点5的最近路径，结果为[1, 3, 4, 5]，表示最近路径是从节点1到节点3，再到节点4，最后到节点5。您可以根据您的实际需求修改节点对象和算法类中的代码。