【算法】克鲁斯卡尔算法求最小生成树

已于 2024-08-15 00:21:52 修改
阅读量468 收藏 15
点赞数 13
文章标签： 算法
于 2024-08-14 23:59:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_78914800/article/details/141176172
版权

目录

1.应用场景-公交站问题

2.克鲁斯卡尔算法介绍

3.图解克鲁斯卡尔算法

3.1第 1 步：选取边 ,f>

3.2第 2 步：选取边 ,d>

3.3第 3 步：选取边 ,e>

3.4第 4 步：选取边 ,f>

3.5第 5 步：选取边 ,g>

3.6第 6 步，选取边 ,b>

4.克鲁斯卡尔的代码实现

4.1打印邻接矩阵

4.2将边的权值排序 

4.3最终版-克鲁斯卡尔求最小生成树

1.应用场景-公交站问题

1.某城市新增 7 个站点（A,B,C,D,E,F,G），现在需要修路把七个站点连通

2.各个站点的距离用边线表示（权），比如 A - B 距离12公里

3.问：如何修路保证各个站点都能连通，并且修建公路总里程最短

2.克鲁斯卡尔算法介绍

1.克鲁斯卡尔算法是用来求加权连通图的最小生成树的算法

2.基本思路：为了连通 n 个顶点，按照权值从小到大的顺序选择 n-1 条边，并保证这 n-1 条边不构成回路

3.具体做法：首先构造一个只含 n 个顶点的森林，然后按照权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止

3.图解克鲁斯卡尔算法

假设数组 R 保存最小生成树结果

3.1第 1 步：选取边 <E,F>

边 <E,F> 的权值最小，因此将它加入到最小生成树结果 R 中 

3.2第 2 步：选取边 <C,D>

 经过了上一步操作，边 <C,D> 的权值最小，因此将它加入到最小生成树结果 R 中 

3.3第 3 步：选取边 <D,E>

 经过了上一步操作，边 <D,E> 的权值最小，因此将它加入到最小生成树结果 R 中  

3.4第 4 步：选取边 <B,F>

第四步本应该选择剩余最小边 <C,E>，但是我们却没有选 <C,E>，也没有选 <C,F>，这是因为我们要避免形成回路

3.5第 5 步：选取边 <E,G>

3.6第 6 步，选取边 <A,B>

此时，最小生成树构建完成，它包括的边依次是 <E,F><C,D><D,E><B,F><E,G><A,B>

由以上图解我们得知，克鲁斯卡尔有两个核心：一是对边的权值进行排序，二是判断是否产生回路

排序这个问题很好解决，采用排序算法进行排序即可

判断回路的方法是：记录顶点在“最小生成树”中的终点，所谓顶点的终点就是“在最小生成树中与它连通的最大顶点”。然后每次需要将一条边添加到最小生成树时，判断该边的两个顶点的终点是否重合，重合的话则构成回路。说到这里，在座的各位已经懵了，下面我们用图解的方式来解释一下判断回路的方法

我们回退到第 4 步

在将 <E,F><C,D><D,E> 加入到最小生成树 R 中之后，这几条边的顶点就有了终点

1.C 的终点是 F

2.D 的终点是 F

3.E 的终点是 F

4.F 的终点是 F

关于终点的说明：

1.将所有顶点按照从小到大的顺序排好之后，某个顶点的终点就是“与它连通的最大顶点”

2.因此，接下来，虽然 <C,E>是权值最小的边，但是 C 和 E 的终点都是 F，即它们的终点相同，因此，将 <C,E> 加入最小生成树的话，会形成回路。这就是判断回路的方式。也就是说，我们加入的边的两个顶点不能都指向同一个终点，否则将形成回路

4.克鲁斯卡尔的代码实现

4.1打印邻接矩阵

public class KruskalCase {

    private int edgeNum;  //边的个数
    private char[] vertexs;  //顶点数组
    private int[][] matrix;  //邻接矩阵
    // 使用 INF 表示两个顶点不能连通
    private static final int INF = Integer.MAX_VALUE;

    public static void main(String[] args) {
        char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int[][] matrix = {
                {  0, 12,INF,INF,INF, 16, 14},
                { 12,  0, 10,INF,INF,  7,INF},
                {INF, 10,  0,  3,  5,  6,INF},
                {INF,INF,  3,  0,  4,INF,INF},
                {INF,INF,  5,  4,  0,  2,  8},
                { 16,  7,  6,INF,  2,  0,  9},
                { 14,INF,INF,INF,  8,  9,  0}
        };
        KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
        kruskalCase.print();
    }

    //构造器
    public KruskalCase(char[] vertexs, int[][] matrix) {
        //初始化顶点数和边的个数
        int vlen = vertexs.length;

        //初始化顶点，使用复制拷贝的方式
        this.vertexs = new char[vlen];
        for (int i = 0; i < vlen; i++) {
            this.vertexs[i] = vertexs[i];
        }

        //初始化边，使用复制拷贝的方式
        this.matrix = new int[vlen][vlen];
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                this.matrix[i][j] = matrix[i][j];
            }
        }
        //统计边的条数
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                if (this.matrix[i][j] != INF) {
                    edgeNum++;
                }
            }
        }

    }

    //打印邻接矩阵
    public void print() {
        System.out.println("邻接矩阵为：\n");
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = 0; j < vertexs.length; j++) {
                System.out.printf("%15d", matrix[i][j]);
            }
            System.out.println();
        }
    }

}

4.2将边的权值排序 

public class KruskalCase {

    private int edgeNum;  //边的个数
    private char[] vertexs;  //顶点数组
    private int[][] matrix;  //邻接矩阵
    // 使用 INF 表示两个顶点不能连通
    private static final int INF = Integer.MAX_VALUE;

    public static void main(String[] args) {
        char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int[][] matrix = {
                {  0, 12,INF,INF,INF, 16, 14},
                { 12,  0, 10,INF,INF,  7,INF},
                {INF, 10,  0,  3,  5,  6,INF},
                {INF,INF,  3,  0,  4,INF,INF},
                {INF,INF,  5,  4,  0,  2,  8},
                { 16,  7,  6,INF,  2,  0,  9},
                { 14,INF,INF,INF,  8,  9,  0}
        };
        KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
        kruskalCase.print();
        EData[] edges = kruskalCase.getEdges();
        System.out.println("排序前：\n" + Arrays.toString(edges));
        kruskalCase.sortEdges(kruskalCase.getEdges());
        System.out.println("排序后：\n" + Arrays.toString(edges));
    }

    //构造器
    public KruskalCase(char[] vertexs, int[][] matrix) {
        //初始化顶点数和边的个数
        int vlen = vertexs.length;

        //初始化顶点，使用复制拷贝的方式
        this.vertexs = new char[vlen];
        for (int i = 0; i < vlen; i++) {
            this.vertexs[i] = vertexs[i];
        }

        //初始化边，使用复制拷贝的方式
        this.matrix = new int[vlen][vlen];
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                this.matrix[i][j] = matrix[i][j];
            }
        }
        //统计边的条数
        for (int i = 0; i < vlen; i++) {
            for (int j = i+1; j < vlen; j++) {
                if (this.matrix[i][j] != INF) {
                    edgeNum++;
                }
            }
        }

    }

    //打印邻接矩阵
    public void print() {
        System.out.println("邻接矩阵为：\n");
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = 0; j < vertexs.length; j++) {
                System.out.printf("%12d", matrix[i][j]);
            }
            System.out.println();
        }
    }
    
    /**
     * 功能：对边进行排序处理，冒泡排序
     * @param edges  边的集合
     */
    private void sortEdges(EData[] edges) {
        for (int i = 0; i < edges.length - 1; i++) {
            for (int j = 0; j < edges.length - 1 - i; j++) {
                if (edges[j].weight > edges[j+1].weight) {  //交换
                    EData tmp = edges[j];
                    edges[j] = edges[j+1];
                    edges[j+1] = tmp;
                }
            }
        }
    }

    /**
     *
     * @param ch 顶点的值，比如 'A' 'B'
     * @return 返回 ch 顶点对应的下标，如果找不到，返回 -1
     */
    private int getPosition(char ch) {
        for (int i = 0; i < vertexs.length; i++) {
            if (vertexs[i] == ch) {  //找到
                return i;
            }
        }
        //找不到，返回 -1
        return -1;
    }

    /**
     * 功能：获取图中的边，放到 EData[] 数组中，后面我们需要遍历该数组
     * 是通过 matrix 邻接矩阵来获取
     * EData[] 形式 [['A','B',12], ['B','F',7]......]
     * @return
     */
    private EData[] getEdges() {
        int index =0;
        EData[] edges = new EData[edgeNum];
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = i+1; j < vertexs.length; j++) {
                if (matrix[i][j] != INF) {
                    edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }

    /**
     * 功能：获取下标为 i 的顶点的终点，用于判断两个顶点的终点是否相同
     * @param ends 记录各个顶点的终点是哪个
     * @param i 传入的顶点对应的下标
     * @return
     */
    private int getEnd(int[] ends, int i) {
        while (ends[i] != 0) {
            i = ends[i];
        }
        return  i;
    }

}

//创建一个类 EData，它的对象实例就表示一条边
class EData {
    char start;  //边的一个点
    char end;  //边的另外一个点
    int weight;  //边的权值
    //构造器
    public EData(char start, char end, int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
    }
    //重写 toString，便于输出边信息
    @Override
    public String toString() {
        return "EData{" +
                "start=" + start +
                ", end=" + end +
                ", weight=" + weight +
                '}';
    }
}

4.3最终版-克鲁斯卡尔求最小生成树

public class KruskalCase {

    private int edgeNum;  //边的个数
    private char[] vertexs;  //顶点数组
    private int[][] matrix;  //邻接矩阵
    // 使用 INF 表示两个顶点不能连通
    private static final int INF = Integer.MAX_VALUE;

    public static void main(String[] args) {
        char[] vertexs = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int[][] matrix = {
                {  0, 12,INF,INF,INF, 16, 14},
                { 12,  0, 10,INF,INF,  7,INF},
                {INF, 10,  0,  3,  5,  6,INF},
                {INF,INF,  3,  0,  4,INF,INF},
                {INF,INF,  5,  4,  0,  2,  8},
                { 16,  7,  6,INF,  2,  0,  9},
                { 14,INF,INF,INF,  8,  9,  0}
        };
        //创建 KruskalCase 对象实例
        KruskalCase kruskalCase = new KruskalCase(vertexs, matrix);
        kruskalCase.print();
        kruskalCase.kruskal();
    }

    //构造器
    public KruskalCase(char[] vertexs, int[][] matrix) {
        //初始化顶点数和边的个数
        int vlen = vertexs.length;

        //初始化顶点，使用复制拷贝的方式
        this.vertexs = new char[vlen];
        for (int i = 0; i < vlen; i++) {
            this.vertexs[i] = vertexs[i];
        }

        //初始化边，使用复制拷贝的方式
        this.matrix = new int[vlen][vlen];
        for (int i = 0; i < vlen; i++) {
            for (int j = 0; j < vlen; j++) {
                this.matrix[i][j] = matrix[i][j];
            }
        }
        //统计边的条数
        for (int i = 0; i < vlen; i++) {
            for (int j = i+1; j < vlen; j++) {
                if (this.matrix[i][j] != INF) {
                    edgeNum++;
                }
            }
        }

    }
    public void kruskal() {
        int index = 0;  //表示最后结果的索引
        int[] ends = new int[edgeNum];  //用于保存 已有最小生成树 中的每个顶点在最小生成树的终点
        //创建结果数组，保存最后的最小生成树
        EData[] rets = new EData[edgeNum];
        //获取图中所有的边的集合，一共有 12 条边
        EData[] edges = getEdges();

        // 按照边的权值大小进行排序（从小到大）
        sortEdges(edges);

        //遍历 edges 数组，将边添加到最小生成树中，判断准备加入的边是否形成了回路，如果没有，就加入 rets，否则不加入
        for (int i = 0; i < edgeNum; i++) {
            //获取到第 i 条边的第一个顶点（起点）
            int p1 = getPosition(edges[i].start);
            //获取到第 i 条边的第 2 个顶点
            int p2 = getPosition(edges[i].end);

            //获取 p1 这个顶点在已有最小生成树中的终点
            int m = getEnd(ends, p1);
            //获取 p2 这个顶点在已有最小生成树中的终点
            int n = getEnd(ends, p2);
            //是否构成回路
            if (m != n) {  //没有构成回路
                ends[m] = n;  //设置 m 在 已有最小生成树 中的终点
                rets[index++] = edges[i];  //有一条边加入到 rets 数组
            }
        }

        //统计并打印 最小生成树，输出 rets
        System.out.println("最小生成树为：" + Arrays.toString(rets));
    }

    //打印邻接矩阵
    public void print() {
        System.out.println("邻接矩阵为：\n");
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = 0; j < vertexs.length; j++) {
                System.out.printf("%12d", matrix[i][j]);
            }
            System.out.println();
        }
    }
    
    /**
     * 功能：对边进行排序处理，冒泡排序
     * @param edges  边的集合
     */
    private void sortEdges(EData[] edges) {
        for (int i = 0; i < edges.length - 1; i++) {
            for (int j = 0; j < edges.length - 1 - i; j++) {
                if (edges[j].weight > edges[j+1].weight) {  //交换
                    EData tmp = edges[j];
                    edges[j] = edges[j+1];
                    edges[j+1] = tmp;
                }
            }
        }
    }

    /**
     *
     * @param ch 顶点的值，比如 'A' 'B'
     * @return 返回 ch 顶点对应的下标，如果找不到，返回 -1
     */
    private int getPosition(char ch) {
        for (int i = 0; i < vertexs.length; i++) {
            if (vertexs[i] == ch) {  //找到
                return i;
            }
        }
        //找不到，返回 -1
        return -1;
    }

    /**
     * 功能：获取图中的边，放到 EData[] 数组中，后面我们需要遍历该数组
     * 是通过 matrix 邻接矩阵来获取
     * EData[] 形式 [['A','B',12], ['B','F',7]......]
     * @return
     */
    private EData[] getEdges() {
        int index =0;
        EData[] edges = new EData[edgeNum];
        for (int i = 0; i < vertexs.length; i++) {
            for (int j = i+1; j < vertexs.length; j++) {
                if (matrix[i][j] != INF) {
                    edges[index++] = new EData(vertexs[i], vertexs[j], matrix[i][j]);
                }
            }
        }
        return edges;
    }

    /**
     * 功能：获取下标为 i 的顶点的终点，用于判断两个顶点的终点是否相同
     * @param ends 记录各个顶点的终点是哪个
     * @param i 传入的顶点对应的下标
     * @return
     */
    private int getEnd(int[] ends, int i) {
        while (ends[i] != 0) {
            i = ends[i];
        }
        return  i;
    }

}

//创建一个类 EData，它的对象实例就表示一条边
class EData {
    char start;  //边的一个点
    char end;  //边的另外一个点
    int weight;  //边的权值
    //构造器
    public EData(char start, char end, int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
    }
    //重写 toString，便于输出边信息
    @Override
    public String toString() {
        return "EData{" +
                "<" + start +
                ", " + end +
                "> =" + weight +
                '}';
    }
}
我想吃羊肉串
关注
  • 13
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
克鲁斯卡尔算法c语言,最小生成树-克鲁斯卡尔(Kruskal)算法
weixin_34929072的博客
05-19 1170
1. 克鲁斯卡尔算法简介克鲁斯卡尔算法是一种用来寻找最小生成树的算法(用来求加权连通图的最小生成树的算法)。在剩下的所有未选取的边中，找最小边，如果和已选取的边构成回路，则放弃，选取次小边。而具体的操作过程为：a) 将图的所有连接线去掉，只剩顶点b) 从图的边集数组中找到权值最小的边，将边的两个顶点连接起来c) 继续寻找权值最小的边，将两个顶点之间连接起来，如果选择的边使得最小生成树出现了环路，...
【图算法】最小生成树之克鲁斯卡尔算法
无意呢的博客
03-05 828
最小生成树   在含有n个顶点的连通图中选择n-1条边，构成一棵极小连通子图，并使该连通子图中n-1条边上权值之和达到最小，则称其为连通网的最小生成树。 克鲁斯卡尔算法(Kruskal) 克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 **基本思想：**按照权值从小到大的顺序选择n-1条边，并保证这n-1条边不构成回路。 **具体做法：**首先构造一个只含n个顶点的森林，...
利用克鲁斯卡尔算法求最小生成树
qq_43941925的博客
12-08 3479
思路:最小生成树即为无向连通图G的一个子图如果是一颗包含G的所有顶点且权最小的树则称为最小生成树。克鲁斯卡尔算法的基本思想是以边为主导地位，始终选择当前可用的（所选的边不能构成回路）最小权值边。所以第一步是将所有边按照权值从小到大的顺序排序，接下来从小到大依次考察每一条边。具体实现过程如下： <1>设一个有n个顶点的连通网络为G（V,E），最初先构造一个只有n个顶点，没有边的非连通图T...
克鲁斯卡尔算法生成最小生成树
interesting_code的博客
02-22 1万+
克鲁斯卡尔算法的介绍 1)克鲁斯卡尔(Kruskal)算法，是用来求加权连通图的最小生成树的算法。 2)基本思想：按照权值从小到大的顺序选择 n-1条边，并保证这 n-1条边不构成回路 3)具体做法：首先构造一个只含 n个顶点的森林，然后依权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止 首先我们得明白，在解决求最小生成树的算法里，主要就是克鲁斯...
克鲁斯卡尔算法求最小生成树
‎‎‎‎‎不想吃泡面
06-12 6423
1.克鲁斯卡尔算法     克鲁斯卡尔算法的核心思想是从边集出发，逐步把代价最小且不与已经加到最小生成树的边集构成回路的边加入到最小生成树的边集中，直到求出构成最小生成树的n-1边（n是图的顶点数）。算法的基本步骤如下。 对边集进行排序。 从权值最小的边开始，如果这条边连接的两个节点于图G中不在同一个连通分量中，则添加这条边到图G中。（简单的说就是试探性的加入这条边看加入后是否构成环）。 重复2，直至图G中所有的节点都在同一个连通分量中。   
【算法】最小生成树——克鲁斯卡尔 (Kruskal) 算法
代码星辰的博客
01-19 2606
本文介绍了克鲁斯卡尔算法的概述、代码实现以及应用。
最小生成树之克鲁斯卡尔算法和普里姆算法
热门推荐
青萍之末的博客
06-04 3万+
一、最小生成树简介   假设有一个很实际的问题：我们要在n个城市中建立一个通信网络，则连通这n个城市需要布置n-1一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？   于是我们就可以引入连通图来解决我们遇到的问题，n个城市就是图上的n个顶点，然后，边表示两个城市的通信线路，每条边上的权重就是我们搭建这条线路所需要的成本，所以现在我们有n个顶点的连通网可以建立不同的生成...
Java之克鲁斯卡尔算法求最小生成树
weixin_41347226的博客
09-23 683
创建一个类EData，它的对象实例就表示一条边 public class EData { char start;//边的一个点 char end;//边的另外一个点 int weight;//边的权值 //构造器 public EData(char start, char end, int weight) { this.start = start; this.end = end; this.weight = weigh
最小生成树（克鲁斯卡尔算法 普里姆算法）
weixin_53699414的博客
04-24 2万+
最小生成树是处理图结构中，简化图的算法；即删除一些边使得图得以简化，形成树结构，但应保证图中任意点都是相连通的。形成的最小生成树应该使得从顶点遍历时走过边的权值和最小。（有n个节点，则最小生成树的边数应为n-1） 如： 变为最小生成树后： 处理最小生成树有两种方法： 1.克鲁斯卡尔算法（kruskal）： 这种算法是先把所有的边拿出来，按其权值从小到大的顺序排列，然后从最小的边开始还原图，即按该边连接其顶点。从权值值最小的边依次连接，每次连接都要判断本次连接是否形成了环，若是，则改变没有必要还原，当还原
C语言实现最小生成树之克鲁斯卡尔算法
Arithmetic-logic
08-07 1226
图示 难点是：当选择最后一条边时，v2-v3是5，v1-v4也是5，但是v1-v4一旦连上就会出现环且这个图不是连通图，所以在代码中如何判断环的出现和保证最小生成树是连通的？ 代码 //定义一个结构体记录生成树一条边的起始顶点和终止顶点，还有相应的权值的信息 typedef struct Edge { int x; // start int y; // end E cost; }Edge; int cmp(const void*a, const void *b)//比较权值的大小 { re
Python采用Kruskal(克鲁斯卡尔)算法实现最小生成树
05-22
### Python 实现 Kruskal(克鲁斯卡尔)算法构建最小生成树 #### 最小生成树的概念 最小生成树（Minimum Spanning Tree, MST）是针对一个无向加权连通图的一种特殊子图结构。它能够连接图中的所有顶点（节点），并且...
Java 使用克鲁斯卡尔求最小生成树（源代码）
05-17
克鲁斯卡尔算法是一种著名的贪心算法，它用于解决无向加权图中的最小生成树问题。所谓最小生成树，是指在一个连通的无向图中，选取n-1条边（其中n为顶点数），使得这n-1条边连接所有的顶点，且这n-1条边的总权重最小...
Prim与Kruskal算法的最小生成树matlab实现
05-26
在通信网理论作业3-最小生成树这个项目中，你可能会学习如何用MATLAB编写代码，实现Prim和Kruskal算法，并对给定的网络图数据进行最小生成树的构造。这将涉及到数据结构的设计、图的遍历以及最小生成树的验证等编程...
最小生成树 克鲁斯卡尔算法 kruskal
06-30
最小生成树是图论中的一个重要概念，用于寻找连接无向图中所有顶点的边集，使得这组边的总权重最小。克鲁斯卡尔（Kruskal）算法是一种求解最小生成树的经典方法，由约瑟夫·克鲁斯卡尔在1956年提出。它基于贪心策略...
Kruskal克鲁斯卡尔算法构造最小生成树的动画.zip
05-10
《克鲁斯卡尔算法：构建最小生成树的精要解析》 在图论的世界里，寻找最优化解决方案是一项常见的挑战。其中，构造最小生成树（Minimum Spanning Tree, MST）是一个核心问题，它旨在找到一个无环连通子图，使得连接...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 497
开始，
排序算法之桶排序
rd_w_csdn的博客
08-12 819
桶排序（bucket sort）是分治策略的一个典型应用。它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据平均分配到各个桶中；然后，在每个桶内部分别执行排序；最终按照桶的顺序将所有数据合并。
备战秋招60天算法挑战，Day17
最新发布
溜达虎的博客
08-13 365
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
算法：魔法字典
Garson的博客
08-12 548
设计一个使用单词列表进行初始化的数据结构，单词列表中的单词。如果给出一个单词，请判定能否只将这个单词中字母换成另一个字母，使得所形成的新单词存在于你构建的字典中。实现dictionarydictionarysearchWordtruefalse// 返回 False// 将第二个 'h' 替换为 'e' 可以匹配 "hello" ，所以返回 True// 返回 False// 返回 FalsedictionarybuildDictsearch100search。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值