算法

最新推荐文章于 2021-07-14 22:22:15 发布
最新推荐文章于 2021-07-14 22:22:15 发布
阅读量307 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaoxuyang1997/article/details/102479460
版权

[数据结构][算法][面向对象][Java]
https://github.com/z8g/common

文章目录

1 设计接口

1.1 容器接口Container

package ds;
import java.util.NoSuchElementException;
public interface Container{
   
    int size();
    
    default boolean isEmpty(){
   
        return size() == 0;
    }
    default void notEmptyCheck() {
   
        if (isEmpty()) {
   
            throw new NoSuchElementException("size == 0");
        }
    }
}

1.2 背包接口Bag

package ds;

public interface Bag<T> extends Container {
   
    void add(T data);
}

1.3 栈接口Stack

package ds;

public interface Stack<T>extends Container {
   
    void push(T data);
    T pop();
    T peek();
}

1.4 队列接口Queue

package ds;

public interface Queue<T> extends Container {
   
    T peek();
    void enqueue(T data);
    T dequeue();
}

1.5 Union-Find算法接口UF

package ds;

public interface UF {
   
    int size();
    int find(int p);
    boolean connected(int p, int q);
    void union(int p, int q);
    default void validate(int p, int n) {
   
        if (p < 0 || p >= n) {
   
            throw new IllegalArgumentException("p>=0 && p<n");
        }
    }
}

2 实现接口

为数组和链表定义了公共的结点和迭代器实现。

2.1 结点类Node

package ds.util;

public class Node<T> {
   
   public T data;
   public Node<T> next;
}

2.2 数组迭代器ArrayIterator

package ds.util;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class ArrayIterator<T> implements Iterator<T> {
   
    private int i;
    private final int size;
    private final T[] array;
    public ArrayIterator(T[] array, int size) {
   
        this.array = array;
        this.size = size;
    }
    @Override
    public boolean hasNext() {
   
        return i < size;
    }
    @Override
    public T next() {
   
        if (!hasNext()) {
   
            throw new NoSuchElementException();
        }
        return array[i++];
    }
}

2.3 链表迭代器ListIterator

package ds.util;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class ListIterator<T> implements Iterator<T> {
   
    private Node<T> current;
    public ListIterator(Node<T> first) {
   
        current = first;
    }
    @Override
    public boolean hasNext() {
   
        return current != null;
    }
    @Override
    public T next() {
   
        if (!hasNext()) {
   
            throw new NoSuchElementException();
        }
        T result = current.data;
        current = current.next;
        return result;
    }
}

2.4 背包(Bag)的实现

背包(Bag)是一种不支持从中删除元素的集合数据类型。

2.4.1 能动态调整数组大小的Bag
package ds.impl;
import ds.Bag;
import java.util.Iterator;
import ds.util.ArrayIterator;

public class ArrayBag<T> implements Iterable<T>,Bag<T> {
   
    private T[] array;
    private int size;
    public ArrayBag() {
   
        array = (T[]) new Object[2];
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void add(T data) {
   
        if (size == array.length) {
   
            resize(2 * array.length);
        }
        array[size++] = data;
    }
    private void resize(int capacity) {
   
        assert capacity >= 0;
        T[] tmp = (T[]) new Object[capacity];
        System.arraycopy(array, 0, tmp, 0, size);
        array = tmp;
    }
    
    @Override
    public Iterator<T> iterator() {
   
        return new ArrayIterator(array,size);
    }
    
}
2.4.2 链式Bag的实现
package ds.impl;
import ds.util.Node;
import ds.Bag;
import java.util.Iterator;
import ds.util.ListIterator;

public class LinkedBag<T> implements Iterable<T>, Bag<T> {
   
    private Node<T> first;
    private int size;
    public LinkedBag() {
   
        first = null;
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void add(T data) {
   
        Node<T> old = first;
        first = new Node<>();
        first.data = data;
        first.next = old;
        size++;
    }
    @Override
    public String toString() {
   
        StringBuilder s = new StringBuilder();
        for (T data : this) {
   
            s.append(data).append(' ');
        }
        return s.toString();
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ListIterator(first);
    }
}

2.5 栈(Stack)的实现

栈(Stack)是一种先进后出的数据类型。

2.5.1 能动态调整数组大小的Stack
package ds.impl;
import ds.Stack;
import java.util.Iterator;
import ds.util.ArrayIterator;

public class ArrayStack<T> implements Iterable<T>,Stack<T> {
   
    private T[] array;
    private int size;
    
    public ArrayStack(){
   
        array = (T[]) new Object[2];
        size = 0;
    }
    
    
    @Override
    public Iterator<T> iterator() {
   
        return new ArrayIterator(array,size);
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void push(T data) {
   
        if(size == array.length){
   
            resize(2* array.length);
        }
        array[size++] = data;
    }
    private void resize(int capacity) {
   
        assert capacity >= size;
        T[] tmp = (T[]) new Object[capacity];
        System.arraycopy(array, 0, tmp, 0, size);
        array = tmp;
    }
    
    @Override
    public T pop() {
   
        notEmptyCheck();
        T result = array[size-1];
        array[size-1] = null;
        size--;
        if(size>0 && size == array.length/4){
   
            resize(array.length/2);
        }
        return result;
    }
    
    @Override
    public T peek() {
   
        notEmptyCheck();
        return array[size-1];
    }
}
2.5.2 链式Stack的实现
package ds.impl;
import ds.util.Node;
import ds.Stack;
import java.util.Iterator;
import ds.util.ListIterator;

public class LinkedStack<T> implements Iterable<T>,Stack<T> {
   
    private Node<T> first;
    private int size;
    public LinkedStack() {
   
        first = null;
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    /**
     * 向栈中推入一个新元素
     *
     * @param data 新元素
     */
    @Override
    public void push(T data) {
   
        Node<T> oldFirst = first;
        first = new Node<>();
        first.data = data;
        first.next = oldFirst;
        size++;
    }
    /**
     * 从栈中弹出栈首元素
     *
     * @return 栈首元素
     */
    @Override
    public T pop() {
   
        notEmptyCheck();
        T result = first.data;
        first = first.next;
        size--;
        return result;
    }
    /**
     * 查看栈首元素
     * @return 栈首元素
     */
    @Override
    public T peek() {
   
        notEmptyCheck();
        return first.data;
    }
    @Override
    public String toString() {
   
        StringBuilder s = new StringBuilder();
        for (T data : this) {
   
            s.append(data).append(' ');
        }
        return s.toString();
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ListIterator(first);
    }
}

2.6 队列(Queue)的实现

队列(Queue)是一种先进先出的数据类型。

2.6.1 能动态调整数组大小的Queue
package ds.impl;
import ds.Queue;
import java.util.Iterator;

public class ArrayQueue<T> implements Iterable<T>,Queue<T> {
   
    private T[] array;
    private int size;
    private int first;
    private int last;
    public ArrayQueue() {
   
        array = (T[]) new Object[2];
        size = 0;
        first = 0;
        last = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public void enqueue(T data) {
   
        if (size == array.length) {
   
            resize(2 * array.length);
        }
        array[last++] = data;
        if (last == array.length) {
   
            last = 0;
        }
        size++;
    }
    @Override
    public T dequeue() {
   
        notEmptyCheck();
        T result = array[first];
        array[first] = null;
        size--;
        first++;
        if (first == array.length) {
   
            first = 0;
        }
        if (size > 0 && size == array.length / 4) {
   
            resize(array.length / 2);
        }
        return result;
    }
    
    @Override
    public T peek(){
   
        notEmptyCheck();
        return array[first];
    }
    private void resize(int capacity) {
   
        assert capacity >= size;
        T[] tmp = (T[]) new Object[capacity];
        for (int i = 0; i < size; i++) {
   
            tmp[i] = array[(first + i) % array.length];
        }
        array = tmp;
        first = 0;
        last = size;
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ds.util.ArrayIterator(array,size);
    }
}
2.6.2 链式Queue的实现
package ds.impl;
import ds.util.Node;
import ds.Queue;
import java.util.Iterator;
import ds.util.ListIterator;

public class LinkedQueue<T> implements Iterable<T>, Queue<T> {
   
    private Node<T> first;
    private Node<T> last;
    private int size;
    public LinkedQueue() {
   
        first = null;
        last = null;
        size = 0;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public T peek() {
   
        notEmptyCheck();
        return first.data;
    }
    @Override
    public void enqueue(T data) {
   
        Node<T> oldLast = last;
        last = new Node<>();
        last.data = data;
        last.next = null;
        if (isEmpty()) {
   
            first = last;
        } else {
   
            oldLast.next = last;
        }
        size++;
    }
    @Override
    public T dequeue() {
   
        notEmptyCheck();
        T result = first.data;
        first = first.next;
        size--;
        if (isEmpty()) {
   
            last = null;
        }
        return result;
    }
    @Override
    public String toString() {
   
        StringBuilder s = new StringBuilder();
        for (T data : this) {
   
            s.append(data).append(' ');
        }
        return s.toString();
    }
    @Override
    public Iterator<T> iterator() {
   
        return new ListIterator(first);
    }
}

2.7 Union-Find算法的实现

并查集（Union-Find）是解决动态连通性问题的一类非常高效的数据结构。

2.7.1 DefaultUF
package ds.impl;
import ds.UF;

public class DefaultUF implements UF {
   
    private int[] parent;
    private byte[] rank;
    private int size;
    public DefaultUF(int n) {
   
        if (n < 0) {
   
            throw new IllegalArgumentException();
        }
        size = n;
        parent = new int[n];
        rank = new byte[n];
        for (int i = 0; i < n; i++) {
   
            parent[i] = i;
            rank[i] = 0;
        }
    }
    @Override
    public int find(int p) {
   
        validate(p, parent.length);
        while (p != parent[p]) {
   
            parent[p] = parent[parent[p]];
            p = parent[p];
        }
        return p;
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public boolean connected(int p, int q) {
   
        return find(p) == find(q);
    }
    @Override
    public void union(int p, int q) {
   
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) {
   
            return;
        }
        if (rank[rootP] < rank[rootQ]) {
   
            parent[rootP] = rootQ;
        } else if (rank[rootQ] > rank[rootP]) {
   
            parent[rootQ] = rootP;
        } else {
   
            parent[rootQ] = rootP;
            rank[rootP]++;
        }
        size--;
    }
}
2.7.2 QuickFindUF
package ds.impl;
import ds.UF;

public class QuickFindUF implements UF {
   
    private final int[] id;
    private int size;
    public QuickFindUF(int n) {
   
        size = n;
        id = new int[n];
        for (int i = 0; i < n; i++) {
   
            id[i] = i;
        }
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public int find(int p) {
   
        validate(p, id.length);
        return id[p];
    }
    @Override
    public boolean connected(int p, int q) {
   
        validate(p, id.length);
        validate(q, id.length);
        return id[p] == id[q];
    }
    @Override
    public void union(int p, int q) {
   
        validate(p, id.length);
        validate(q, id.length);
        int pID = id[p];
        int qID = id[q];
        if (pID == qID) {
   
            return;
        }
        for (int i = 0; i < id.length; i++) {
   
            if (id[i] == pID) {
   
                id[i] = qID;
            }
        }
        size--;
    }
}
2.7.3 QuickUnionUF
package ds.impl;
import ds.UF;
public class QuickUnionUF implements UF {
   
    private final int[] parent;
    private int size;
    public QuickUnionUF(int n) {
   
        parent = new int[n];
        size = n;
        for (int i = 0; i < n; i++) {
   
            parent[i] = i;
        }
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public int find(int p) {
   
        validate(p, parent.length);
        while (p != parent[p]) {
   
            p = parent[p];
        }
        return p;
    }
    @Override
    public boolean connected(int p, int q) {
   
        return find(p) == find(q);
    }
    @Override
    public void union(int p, int q) {
   
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) {
   
            return;
        }
        parent[rootP] = rootQ;
        size--;
    }
}
2.7.4 WeightedQuickUnionUF

加权 quick-union算法，是目前所有实现中最优的算法

package ds.impl;
import ds.UF;

public class WeightedQuickUnionUF implements UF {
   
    private final int[] parent;
    private final int[] num;
    private int size;
    public WeightedQuickUnionUF(int n) {
   
        size = n;
        parent = new int[n];
        num = new int[n];
        for (int i = 0; i < n; i++) {
   
            parent[i] = i;
            num[i] = 1;
        }
    }
    @Override
    public int size() {
   
        return size;
    }
    @Override
    public int find(int p) {
   
        validate(p, parent.length);
        while (p != parent[p]) {
   
            p = parent[p];
        }
        return p;
    }
    @Override
    public boolean connected(int p, int q) {
   
        return find(p) == find(q);
    }
    @Override
    public void union(int p, int q) {
   
        int rootP = find(p);
        int rootQ = find(q);
        if (rootP == rootQ) {
   
            return;
        }
        // make smaller root point to larger one
        if (num[rootP] < num[rootQ]) {
   
            parent[rootP] = rootQ;
            num[rootQ] += num[rootP];
        } else {
   
            parent[rootQ] = rootP;
            num[rootP] += num[rootQ];
        }
        size--;
    }
}

2.8 测试

2.8.1 测试Stack

Dijkstra的双栈算数表达式求值算法

package test;
import java.util.Scanner;
import ds.impl.LinkedStack;

public class StackTest {
   
    public static void main(String[] args) {
   
        evaluate();
    }
    /**
     * Dijkstra的双栈算数表达式求值算法
     */
    public static void evaluate() {
   
        String str = "( 1 + ( ( 2.3 + 3 ) / ( sqrt ( 16 ) * ( 5 % 9 ) ) ) )";
        LinkedStack<String> opStack = new LinkedStack<>();
        LinkedStack<Double> valStack = new LinkedStack<>();
        Scanner scanner = new Scanner(str);
        while (scanner.hasNext()) {
   
            String s = scanner.next();
            System.out.print(s + ' ');
            switch (s) {
   
                case "+":
                case "-":
                case "*":
                case "/":
                case "%":
                case "sqrt":
                    opStack.push(s);
                    break;
                case "(":
                    break;
                case ")":
                    String op = opStack.pop();
                    double v = valStack.pop();
                    switch (op) {
   
                        case "+":
                            v = valStack.pop() + v;
                            break;
                        case "-":
                            v = valStack.pop() - v;
                            break;
                        case "*":
                            v = valStack.pop() * v;
                            break;
                        case "/":
                            v = valStack.pop() / v;
                            break;
                        case "%":
                            v = valStack.pop() % v;
                            break;
                        case "sqrt":
                            v = Math.sqrt(v);
                            break;
                        default:
                            break;
                    }
                    valStack.push(v);
                    break;
                default:
                    valStack.push(Double.parseDouble(s));
                    break;
            }
        }
        System.out.printf("= %f\n", valStack.pop());
    }
}
2.8.2 测试Union-Find
package test;
import ds.UF;
import ds.impl.DefaultUF;
import ds.impl.QuickFindUF;
import ds.impl.QuickUnionUF;

public class UFTest {
   
    public static void main(String[] args) {
   
        UF uf;
        int findResult;
        uf = new QuickFindUF(10);
        uf.union(4, 3);
        uf.union(3, 8);
        uf.union(6, 5);
        uf.union(9, 4);
        uf.union(2, 1);
        uf.union(5, 0);
        uf.union(7, 2);
        uf.union(6, 1);
        findResult = uf.find(3);
        System.out.println(findResult);
        System.out.println(uf.size());
        System.out.println(uf.connected(4, 3));
        System.out.println(uf.connected(9, 3));
        uf = new DefaultUF(10);
        uf.union(4, 3);
        uf.union(3, 8);
        uf.union(6, 5);
        uf.union(9, 4);
        uf.union(2, 1);
        uf.union(5, 0);
        uf.union(7, 2);
        uf.union(6, 1);
        findResult = uf.find(3);
        System.out.println(findResult);
        System.out.println(uf.size());
        System.out.println(uf.connected(4, 3));
        System.out.println(uf.connected(9, 3));
        uf = new QuickUnionUF(10);
        uf.union(4, 3);
        uf.union(3, 8);
        uf.union(6, 5);
        uf.union(9, 4);
        uf.union(2, 1);
        uf.union(5, 0);
        uf.union(7, 2);
        uf.union(6, 1);
        findResult = uf.find(3);
        System.out.println(findResult);
        System.out.println(uf.size());
        System.out.println(uf.connected(4, 3));
        System.out.println(uf.connected(9, 3));
    }
}

3 排序算法

3.1 定义排序工具的类结构

需要实现排序器，以及通过静态方法调用。

package util;
import java.util.Arrays
最低0.47元/天 解锁文章
z8g
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
由最小生成树（MST）到并查集(UF)
weixin_30258901的博客
04-20 72
背景 最小生成树（Minimum Spanning Tree）的算法中，克鲁斯卡尔算法（Kruskal‘s algorithm）是一种常用算法. 在克鲁斯卡尔算法中的一个关键问题是如何判断图中的两个点是否形成环（cycle），那么一种高效的判断方式就是使用并查集技术（Union-Find）. 代码 /** * Created by 浩然 on 4/19/15. * ...
表达式的操作（UF函数）
qq_38344087的博客
03-13 2330
首先创建一个长方体，然后利用函数UF_MODL_ask_exps_of_feature访问长方体特征中的所有表达式的个数和标识，利用函数UF_MODL_ask_exp_tag_string获得表达式字符串，并用函数UF_MODL_dissect_exp_string分离表达式的名称和数值，最后利用函数UF_MODL_rename_exp对表达式重命名，并利用函数UF_MODL_eval_exp计算...
UF_VEC3_affine_comb函数的数学原理
u013401364的博客
07-10 786
double* Point1=(double *)malloc(3*sizeof(double)); double dir_r=sqrt(Dir[0]*Dir[0]+Dir[1]*Dir[1]+Dir[2]*Dir[2]); double h=80/dir_r; UF_VEC3_affine_comb(Point ,h,Dir,Point1);
算法--被围绕的区域--BFS/DFS/UF
大魔王
04-05 311
给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的'O' 用 'X' 填充。 示例 1： 输入：board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]] 输出：[["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]] 解释：被围.
并查集详解：UF——UF_Tree——UF_Tree_Weighted逐步优化
sc179的博客
11-15 663
并查集是一种树型的数据结构，它可以高效地进行如下操作： 查询元素p和元素q是否属于同一组； 合并元素p和元素q所在的组。
JAVA近百种算法大全
05-29
Java算法大全是一个包含约100种常见算法的资源库，专为Java程序员设计，用于深入理解和实践编程中的各种算法。这些算法涵盖了数据结构、排序、搜索、图论等多个领域，是提升编程技能和解决问题能力的重要工具。下面...
程序员算法大全
05-04
《程序员算法大全》是针对IT专业人士，特别是程序员和软件开发者设计的一份综合资源，它涵盖了数据结构和算法的广泛知识。这份资料集旨在提升程序员在解决复杂问题时的逻辑思维和编程能力，从而提高其在面试和实际...
JAVA经典算法90题【含源码】
10-10
在编程领域，特别是Java开发，熟练掌握算法是提升技术能力的关键。"JAVA经典算法90题【含源码】"的资源集合为Java初学者提供了一个绝佳的学习平台，旨在通过实际操作来理解和应用各种基础及进阶算法。下面将详细阐述...
算法竞赛入门到进阶 课件+源码
06-17
《算法竞赛入门到进阶 课件+源码》这套资源是为想要在算法竞赛中提升自己能力的初学者和进阶者准备的宝贵资料。它涵盖了从基础到高级的各种算法，通过课件和源码的结合，使学习者能够理论与实践相结合，更好地理解和...
DBSCAN聚类算法matlab代码
03-22
DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的空间聚类算法，它能够发现任意形状的聚类，并且对噪声具有很好的处理能力。在MATLAB中实现DBSCAN，可以帮助我们更方便地...
Union-Find Algorithm Interpretation
guoliangstyle的博客
01-11 213
本文主要讲述对Union-Find算法的个人理解，以下Union-Find算法简称UF。 本文主要参考普林斯顿大学 Robert Sedgewick and Kevin Wayne教授的书籍算法四，他们的网站是https://algs4.cs.princeton.edu/15uf/ 让我们来看看UF算法在做些什么： 首先会初始化N个站点，用0~n-1个整数值代表（N的数据形式
算法--岛屿问题(DFS/BFS/UF)
大魔王
07-14 5240
与岛屿有关的问题 1.岛屿数量 https://leetcode-cn.com/problems/number-of-islands/ 2.岛屿的最大面积 https://leetcode-cn.com/problems/max-area-of-island/ 3.岛屿周长 https://leetcode-cn.com/problems/island-perimeter/ 4.不同岛屿的数量 https://leetcode-cn.com/problems/number-of-distin
普林斯顿大学算法Week1: Percolation 渗透(98分)--总结及代码
littlehaes的博客
01-25 3335
总结 视频讲述了并查集算法的细节,作业是该算法的实际应用 1. 下载algs4.jar,并添加到CLASSPATH中 2. 使用algs4.jar中的工具:求均值,求标准差,输入输出 3. 需要传入外部参数的方法都得进行参数检测,否则扣分 4. UnionFind算法的输入是一维的,Percolation系统是n*n的格子,每个site由坐标对(x,y)表示, 所以要想描述点与点之间的...
kruskal算法基于并查集的实现
weixin_44290841的博客
06-14 300
#include<iostream> #include<algorithm> #include<set> #include<vector> using namespace std; /*并查集*/ struct UF{ UF * parent; UF():parent(NULL){ } }; UF* find(UF* c){ if(c->parent == NULL) return c; set<UF*> s; w
单目标&多目标优化算法的测试函数与解
xuxinrk的博客
10-11 2万+
原文 From Wikipedia, the free encyclopedia In applied mathematics, test functions, known as artificial landscapes, are useful to evaluate characteristics of optimization algorithms, such as: Velocity...
【数据结构与算法】模式匹配——从BF算法到KMP算法（附完整源码）
兰亭风雨的专栏
02-20 2万+
子串的定位操作通常称为串的模式匹配。模式匹配的应用很常见，比如在文字处理软件中经常用到的查找功能。我们用如下函数来表示对字串位置的定位： int index(const string &Tag,const string &Ptn,int pos) 其中，Tag为主串，Ptn为子串（模式串），如果在主串Tag的第pos个位置后存在与子串Ptn相同的子串，返回它在主串Tag中第pos个字符后第一次出现的位置，否则返回-1。 我们先来看BF算法(Brute-Force，最基本的字符串匹配算法)，B
Algorithm Course Review(14.1)
06-16 117
　　第14章，随机算法，random algorithm。 　　随机算法，当算法在执行过程中面临一个选择时，随机行选择常比最优选择快，因此随机算法可以在一定程度上降低算法的复杂度。　　由于随机过程的存在，对所求解问题的同一个输入，可能得到完全不同的输出。　　随机算法一般分为四类，数值随机算法，蒙特卡罗(Monte Carlo)算法，拉斯维加斯（Las Vegas）算法和舍伍德（Sher...
无向图连通性判断的五种方法（BFS、DFS、Union-find、Warshell、Tarjan）
i4053的博客
11-17 3万+
目录 无向连通图的相关定义 主要算法流程  DFS判断： BFS判断： Warshell判断： Union-Find判断： Tarjan判断： 无向连通图的相关定义 连通性：在图G中，两个不同的结点u和结点v之间若存在一条路，则称结点u和结点v是连通的。 无向连通图：若在无向图G中，任意两点都是连通的，则称图G为连通图。 主要算法流程  DFS判断： 从任一结点开始，进行一...
SURF算法解析
热门推荐
PeOS
11-20 5万+
SURF算法解析

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值