js 根据路径获取文件名称,js判断路径是否存在

本文链接：https://blog.csdn.net/2301_79533350/article/details/134852537

大家好，给大家分享一下js 根据路径获取文件名称，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！

Dijkstra算法——求某一个点到其他所有点的最短路径

Dijkstra算法和最小生成树的Prim算法又有异曲同工之妙。都是要将顶点分成两坨，一坨未访问的，一坨已访问的，通过循环将未访问的一次次拉下水，变成访问过的，在这个过程中，每次都找权值最小的路径Deepl降重。

以A点为例：

初始化A点到所有其他点的距离dis = [0, ∞, ∞]（依次代表[【AA】【AB】【AC】]）;
设当前点为A，当前路径dis[0] = 0；
已访问点集为{A}，未访问点集为{B,C}；
从未访问点集{B,C}中找到所有由当前点A和一个未访问集中的点组成的边【AC，10】【AB，8】，
遍历所有找到的边，通过（当前路径权重+找到的边的权重）和（找的边在dis中对应的权重）的比较，取更小的权重。这里∞ > 0 + 8, ∞ > 0 + 10,更新dis = [0, 8, 10];
找出dis中的包含未访问点集中某点的最小权边；此时有三条边【AA,0】【AB,8】【AC,10】，最小权是【AA，0】但是不没有包含未访问点集中的点所以不算，这里是【AB，8】；
这时A通过边【AB】拉下水了一个新的顶点B（为什么第6歩要包含未访问点集中的点）；
设当前点为B，当前路径为dis[1] = 8；
更新已访问点集为{A,B}，未访问点集为{C}；
从未访问点集{C}中找到所有由当前点B和一个未访问集中的点组成的边【BC，1】；
遍历所有找到的边，通过（当前路径权重+找到的边的权重）和（找的边在dis中对应的权重）的比较，取更小的权重，这里10 > 8 + 1 更新dis = [0, 8, 9];
找出dis中的包含未访问点集中某点的最小权边；此时有三条边【AA,0】【AB,8】【AC,9】，【AA，0】【AB，8】没有包含未访问点集中的点所以不算，这里是【AC，9】；
这时A通过边【AC】（实际上是【AB】+【BC】）拉下水了一个新的顶点C；
设当前点为C，当前路径为dis[2] = 9；
更新已访问点集为{A,B,C}，未访问点集为{}；
未访问点集为空，结束。

好了，开始程序设计

还是这张图（图片来源链接）

建立图表示

// 无向图
let vertices = ['A', 'B', 'C', 'D', 'E', 'F', 'G'];
let edges = [
    [0, 1, 12],
    [0, 5, 16],
    [0, 6, 14],
    [1, 2, 10],
    [1, 5, 7],
    [2, 3, 3],
    [2, 4, 5],
    [2, 5, 6],
    [3, 4, 4],
    [4, 5, 2],
    [4, 6, 8],
    [5, 6, 9]
];

一个方法，用于找到所有（由当前点和未访问集中一点组成的边）

/**
 * @deion 找到当前点在未访问点集合中的所有边
 * @param {vertex} src 源顶点
 * @param {Array<vertex>} objs 目标顶点数组
 * @param {Array<edge>} edges 所有边
 * @param {Array<vertex>} vertices 所有顶点
 * @returns {Array} edges
 */
function findEdgesIn(src, objs, edges, vertices) {
    let edgesBetweenSrcObj = [];
    for (const edge of edges) {
        srcIndex = vertices.indexOf(src);
        for (const obj of objs) {
            objIndex = vertices.indexOf(obj);
            if (edge[0] === srcIndex && edge[1] === objIndex || edge[0] === objIndex && edge[1] === srcIndex) { // 无向
            // if (edge[0] === srcIndex && edge[1] === objIndex) { // 有向
                edgesBetweenSrcObj.push(edge);
            }
        }
    }
    return edgesBetweenSrcObj;
}

男主角（dijkstra）

function dijkstra(vertices, edges, startVertex) {
    let infected = []; // 已访问点集
    let remained = vertices.slice(0); // 未访问的点集
    let shortestPath = vertices.slice(0).map(d => Infinity); // 路径数组
    shortestPath[vertices.indexOf(startVertex)] = 0; // 到自己路径为0
    let cur = startVertex; // 起始顶点
    while (remained.length !== 0) {
        infected.push(cur); // 标记当前点已访问(即顶点访问顺序)
        let curIndex = vertices.indexOf(cur); // 当前点索引
        remained.splice(remained.indexOf(cur), 1); // 从未访问中删除当前点
        let foundEdges = findEdgesIn(cur, remained, edges, vertices); // 找到所有含有当前点的边
        for (const e of foundEdges) {
            let eIndex = curIndex === e[0] ? e[1] : e[0]; // 顶点索引，无向
            // let eIndex = e[1]; // 顶点索引，有向
            if(shortestPath[eIndex] > shortestPath[curIndex] + e[2]){
                shortestPath[eIndex] = shortestPath[curIndex] + e[2]; // 更新路径
            }
        }
        let newIndex = null; // 最小边新入顶点索引
        for(let i = 0; i < shortestPath.length; i ++){
            if(remained.indexOf(vertices[i]) !== -1){
                // 从未被访问的点中找一个最短路径，返回其顶点索引
                newIndex = newIndex ? (shortestPath[newIndex] < shortestPath[i] ? newIndex : i) : i;
            }
        }
        cur = vertices[newIndex]; // 更新当前顶点
    }
    return {
        path: infected,
        distance: shortestPath
    }
}

// 打印结果
{ path: [ 'A', 'B', 'G', 'F', 'C', 'D', 'E' ],
  distance: [ 0, 12, 22, 25, 27, 16, 14 ] }

Floyd算法——求各个顶点两两之间的最短路径

感谢该文章作者的讲解，本文借用其所讲的例子，故列出原文链接，尊重版权（顺带一提，博客左下角有惊喜）。
参考文章：最短路径Floyd算法【图文详解】 - Angel_Kitty - 博客园

简单粗暴的核心：3个for循环

其实核心思想是：将每条路径拆分成其他两条路径的组合，如果两条路径组合的权重更小就替代之。

细节的我不码字了，上代码以供参考。老板，上图！

表示图形

// 矩阵存储
let graphMatrix = [
    [0, 2, 6, 4],
    [Infinity, 0, 3, Infinity],
    [7, Infinity, 0, 1],
    [5, Infinity, 12, 0]
];

Floyd算法

// 最短路径弗洛伊德算法
function floyd(graphMatrix) {
    let matrixCopy = graphMatrix.slice(0);
    for (let i = 0; i < graphMatrix.length; i++) {
        // Ai矩阵
        for (let j = 0; j < graphMatrix.length; j++) {
            for (let k = 0; k < graphMatrix.length; k++) {
                matrixCopy[j][k] = Math.min(matrixCopy[j][k], matrixCopy[j][i] + matrixCopy[i][k]);
            }
        }
    }
    console.log(matrixCopy)
    return matrixCopy;
}

// 打印结果
[ [ 0, 2, 5, 4 ],
  [ 9, 0, 3, 4 ],
  [ 6, 8, 0, 1 ],
  [ 5, 7, 10, 0 ] ]

2022年5月8日22:43:21 补充一个获取路径的函数。上面的方法只记录了权重，当需要路径时，可以利用一个矩阵存储每条路径的前置路径，遍历拿到。

/**
 * 图的最短路径
 * @param {string[]} vertex 顶点
 * @param {number[][]} matrix 邻接矩阵
 */
function createGraph(vertex, matrix) {
    const size = vertex.length;

    const pathTable = [];
    const weightTable = [];

    (function init() {
        for (let i = 0; i < size; i++) {
            pathTable[i] = [];
            weightTable[i] = [];
            for (let j = 0; j < size; j++) {
                pathTable[i][j] = j;
                weightTable[i][j] = matrix[i][j];
            }
        }
    })();

    (function floyd() {
        for (let i = 0; i < weightTable.length; i++) {
            for (let j = 0; j < weightTable.length; j++) {
                for (let k = 0; k < weightTable.length; k++) {
                    if (weightTable[j][k] > weightTable[j][i] + weightTable[i][k]) {
                        pathTable[j][k] = pathTable[j][i];
                        weightTable[j][k] = weightTable[j][i] + weightTable[i][k];
                    }
                }
            }
        }
    })();

    function getPathByIndex(i, j) {
        const path = [i];
        let nxt = pathTable[i][j];
        while (nxt !== j) {
            path.push(nxt);
            nxt = pathTable[nxt][j];
        }
        path.push(j);
        return path;
    }

    return {
        getPath(startVertice, endVertice) {
            const startIndex = vertex.findIndex((v) => v === startVertice);
            const endIndex = vertex.findIndex((v) => v === endVertice);

            return {
                path: getPathByIndex(startIndex, endIndex).map(
                    (index) => vertex[index]
                ),
                weight: weightTable[startIndex][endIndex],
            };
        },
    };
}

// test
vertex = ["A", "B", "C", "D", "E", "F", "G"];

matrix = [
    [0, 12, Infinity, Infinity, Infinity, 16, 14],
    [12, 0, 10, Infinity, Infinity, 7, Infinity],
    [Infinity, 10, 0, 3, 5, 6, Infinity],
    [Infinity, Infinity, 3, 0, 4, Infinity, Infinity],
    [Infinity, Infinity, 5, 4, 0, 2, 8],
    [16, 7, 6, Infinity, 2, 0, 9],
    [14, Infinity, Infinity, Infinity, 8, 9, 0],
];

graph = createGraph(vertex, matrix);

graph.getPath('A', 'D'); // path: ['A', 'F', 'E', 'D'] , weight: 22