算法库应用--Brute - Force算法串匹配(顺序串)

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量1.2k 收藏 10
点赞数 16
分类专栏： 算法库应用 文章标签： 算法 开发语言
本文链接：https://blog.csdn.net/qq_57484399/article/details/140232084
版权

学习贺利坚老师关于B-F算法的算法库

数据结构例程——串的模式匹配（Brute-Force算法）_sqstring s, t; strassign(s,"ababcabcacbabcaccab");-CSDN博客

本人规则解析博客

串的匹配 (Brute - Force 算法)_brute force算法-CSDN博客\

版本更新日志

V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰

V1.0

功能函数

利用B-f算法,寻找子串在母串中的位置

/**************************************************
函数名: Find_matching_location
功  能: 利用B-f算法,寻找子串在母串中的位置
参  数: (1)Sequential_string Mother_String:母串
        (2)Sequential_string Son_String:子串
思  路:  从开始逐个对比,如果对比不成功, 则起始位置前移, 计数器初始化, 直到超出长度或找到
注  意:   我们判断是否找到的标志,就是判断 子串计数器是否对比完,然后跳出
返回值:  int: -1--没找到, 其他:找到,返回其数组位序
**************************************************/
int Find_matching_location(Sequential_string Mother_String,Sequential_string Son_String)
{
    int Mother_counter,Son_counter;//同步计数器
    int Mother_begin;//每次对比从母串开始的位置
    Mother_counter = 0;
    Son_counter = 0;
    Mother_counter = 0;
    //Brute-Force算法
    while((Mother_begin+Mother_counter) < Mother_String.length && Son_counter < Son_String.length)
    {
        if(Mother_String.Sequential_string_data[Mother_begin+Mother_counter] == Son_String.Sequential_string_data[Son_counter])
        {
            Mother_counter++;
            Son_counter++;
        }
        else
        {
            Mother_begin++;
            Mother_counter = 0;
            Son_counter = 0;
        }
    }
    //通过判断子串计数器的溢出数值,得出是否找到
    if(Son_counter >= Son_String.length)
    {
        return Mother_begin;
    }
    else
    {
        return (-1);
    }
}

调用的顺序串算法库

头文件

Sequential_string.h
#ifndef _SEQUENTIAL_STRING_H_INCLUDE
#define _SEQUENTIAL_STRING_H_INCLUDE

#include <stdio.h>
#define MaxSize 100 //最多字符个数

//顺序串数据结构
typedef struct
{
    char Sequential_string_data[MaxSize];//数组串数据
    int length;                          //实际串长
}Sequential_string;

//(1)将一个字符串数组赋值给顺序串
void Assignment_Sequential_string(Sequential_string &New_String, char Assign_array[]);
//(2) 复制一个串,到另一个串
void Copy_Sequential_String(Sequential_string &accept_string, Sequential_string copy_string);
//(3)判断两个串是否相等
bool Equal_Sequential_String(Sequential_string judge_string1, Sequential_string judge_string2);
//(4)求顺序串串长
int Length_Sequential_String(Sequential_string measure_string);
//(5)串连接
Sequential_string Connect_Sequential_String(Sequential_string link1, Sequential_string link2);
//(6)求子串(从begin_loation开始的number个字符)
Sequential_string Get_Sequential_Substring(Sequential_string substring, int begin_loation, int number);
//(7)插入串(从从begin_loation开始插入字符串,然后组合成新的串)
Sequential_string Insert_Sequential_String(Sequential_string old_string, int begin_loation,Sequential_string insert_string);
//(8)删除串(从begin 开始的number个字符)
Sequential_string Delete_Sequential_String(Sequential_string old_string, int begin_loation,int number);
//(9)串替换(从begin 开始的number个字符)
Sequential_string Replace_Sequential_String(Sequential_string old_string, int begin_loation,int number,Sequential_string new_string);
//(10)输出展示串
void Display_Sequential_String(Sequential_string show_String);
#endif

库函数

Sequential_string.cpp
#include "Sequential_string.h"

/**************************************************
(1)函数名: Assignment_Sequential_string
功  能: 将一个字符串数组赋值给顺序串
参  数: (1)Sequential_string &New_String:创建的新串
        (2)char Assign_array[]: 原始字符串数组
注  意:  顺序数组,结尾加入'\0'
返回值: 无
**************************************************/
void Assignment_Sequential_string(Sequential_string &New_String, char Assign_array[])
{
    int counter;
    for(counter = 0; Assign_array[counter] != '\0'; counter++)
    {
        New_String.Sequential_string_data[counter] = Assign_array[counter];
    }
    New_String.Sequential_string_data[counter] = '\0';
    New_String.length = counter;    //更新串最大位序
}

/**************************************************
(2)函数名: Copy_Sequential_String
功  能: 复制一个串,到另一个串
参  数: (1)Sequential_string &accept_string: 复制成的串
        (2)Sequential_string copy_string:要复制的串
注  意:  复制成的串,传回的是地址,所以不用传回参数
返回值: 无
**************************************************/
void Copy_Sequential_String(Sequential_string &accept_string, Sequential_string copy_string)
{
    int counter;
    for(counter = 0; counter < copy_string.length;counter++)
    {
        accept_string.Sequential_string_data[counter] = copy_string.Sequential_string_data[counter];
    }
    accept_string.Sequential_string_data[counter] = '\0';
    accept_string.length = copy_string.length;
}
/**************************************************
(3)函数名: Equal_Sequential_String
功  能: 判断两个串是否相等
参  数: (1)Sequential_string judge_string1:第一个串
        (2)Sequential_string judge_string2:第二个串
返回值: bool?是否相等,true:false
**************************************************/
bool Equal_Sequential_String(Sequential_string judge_string1, Sequential_string judge_string2)
{
    bool same = true;
    int counter;
    if(judge_string1.length != judge_string2.length)
    {
        same = false;
    }
    else
    {
        for(counter = 0; counter < judge_string1.length;counter++)
        {
            if(judge_string1.Sequential_string_data[counter] != judge_string2.Sequential_string_data[counter])
            {
                same = false;
                break;
            }
        }
    }
    return same;

}

/**************************************************
(4)函数名: Length_Sequential_String
功  能: 求顺序串串长
参  数: Sequential_string measure_string:要进行测量的串
返回值: int:顺序串长度信息
**************************************************/
int Length_Sequential_String(Sequential_string measure_string)
{
    return measure_string.length;
}

/**************************************************
(5)函数名: Connect_Sequential_String
功  能: 把两个串连接成一个串
参  数: Sequential_string link1, Sequential_string link2:两个要链接的串
返回值: 返回Sequential_string Connection_string: 链接成的串
**************************************************/
Sequential_string Connect_Sequential_String(Sequential_string link1, Sequential_string link2)
{
    Sequential_string Connection_string;
    int counter;
    Connection_string.length = link1.length + link2.length;
    //将第一个串加入链接的串
    for(counter = 0; counter < link1.length; counter++)
    {
        Connection_string.Sequential_string_data[counter] = link1.Sequential_string_data[counter];
    }
    //将第二个串加入链接的串
    for(counter = 0; counter < link2.length; counter++)
    {
        Connection_string.Sequential_string_data[link1.length+counter] = link2.Sequential_string_data[counter];
    }
    Connection_string.Sequential_string_data[link1.length+counter] = '\0';
    return Connection_string;
}

/**************************************************
(6)函数名: Get_Sequential_Substring
功  能: 求子串(从begin_loation开始的number个字符)
参  数: (1)Sequential_string mother_String:母串
        (2)int begin_loation:开始分割子串的位置
        (3)int number:子串的数量
返回值: Sequential_string son_String:得到的子串
**************************************************/
Sequential_string Get_Sequential_Substring(Sequential_string mother_String, int begin_loation, int number)
{
    Sequential_string son_String;
    int counter;
    son_String.length = 0;
    if(begin_loation <= 0 || begin_loation > mother_String.length || number < 0 || begin_loation+number-1>mother_String.length)
    {
        //错误:分割的子字符串的位置错误。
        printf("\nError<6>:The position of the divided substring is wrong.\n");
        return son_String; //    参数不正确返回空串
    }
    for(counter = begin_loation-1; counter < begin_loation+number-1; counter++)
    {
        son_String.Sequential_string_data[counter-begin_loation+1] = mother_String.Sequential_string_data[counter];
    }
    son_String.Sequential_string_data[counter-begin_loation+1] = '\0';
    son_String.length = number;
    return son_String;
}

/**************************************************
(7)函数名: Insert_Sequential_String
功  能: 插入串(从从begin_loation开始插入字符串,然后组合成新的串)
参  数: (1)Sequential_string old_string:在原始串的基础上插入
        (2)int begin_loation: 插入的位置
        (3)Sequential_string insert_string:插入的新串
思  路:  在原有串的基础上,割开一个口子,放上新串,然后组合成新串
返回值: Sequential_string form_string:组合成的新串
**************************************************/
Sequential_string Insert_Sequential_String(Sequential_string old_string, int begin_loation,Sequential_string insert_string)
{
    int counter;
    Sequential_string form_string;
    form_string.length = 0;
    //参数不正确, 返回空串
    if(begin_loation <= 0 || begin_loation > old_string.length+1)
    {
        //错误:插入位置错误
        printf("\nError<7>: wrong insertion position.\n");
        return form_string;
    }
    for(counter = 0; counter < begin_loation-1;counter++)
    {
        form_string.Sequential_string_data[counter] = old_string.Sequential_string_data[counter];
    }

    for(counter = 0; counter < insert_string.length;counter++)
    {
        form_string.Sequential_string_data[begin_loation-1+counter] = insert_string.Sequential_string_data[counter];
    }

    for(counter = begin_loation-1; counter<old_string.length;counter++)
    {
        form_string.Sequential_string_data[insert_string.length+counter] = old_string.Sequential_string_data[counter];
    }
    form_string.Sequential_string_data[insert_string.length+counter] = '\0';
    form_string.length = old_string.length + insert_string.length;
    return form_string;

}
/**************************************************
(8)函数名: Delete_Sequential_String
功  能: 删除串(从begin 开始的number个字符)
参  数: (1)Sequential_string old_string:在原有串的基础上删除
        (2)int begin_loation: 开始删除的位置(从逻辑1开始)
        (3)int number:删除的数量
注  意:  要判断删除的位置和数量是否正确
返回值:Sequential_string new_string:删除完后的新串
**************************************************/
Sequential_string Delete_Sequential_String(Sequential_string old_string, int begin_loation,int number)
{
    int counter;//定义计数器
    Sequential_string new_string;
    new_string.length = 0;
    //合法性判断(begin_loation理应从1开始到leng长度)
    if(begin_loation <= 0 || begin_loation > old_string.length || (begin_loation+number-1) > old_string.length)
    {
        //错误:删除的位置或数量错误。
        printf("Error<8>: Wrong location or quantity of deletion.");
        return new_string;//返回空串
    }
    //择出删除位置之前的串
    for(counter = 0; counter < begin_loation-1;counter++)
    {
        new_string.Sequential_string_data[counter] = old_string.Sequential_string_data[counter];
    }
    //择出删除位置之后的串
    for(counter = begin_loation+number-1; counter < old_string.length; counter++)
    {
        new_string.Sequential_string_data[counter-number] = old_string.Sequential_string_data[counter];
    }
    new_string.Sequential_string_data[counter-number] = '\0';
    new_string.length = old_string.length - number;
    return new_string;
}

/**************************************************
(9)函数名: Replace_Sequential_String
功  能: 串替换(从begin 开始的number个字符)
参  数: (1)Sequential_string old_string:原始串
        (2)int begin_loation:开始替换的位置
        (3)int number:替换的字符个数
        (4)Sequential_string replace_string:要替换成的字符串
思  路: 锁定old_string从begin_loation开始的number个字符,
        然后开始剪切建立新串,
        ①把begin_loation之前的字符加入新串,
        ②要替换成的串加入,
        ③锁定后的字符加入
        ④组合成新串,返回传出
注  意:  最后加'\0'
返回值: Sequential_string new_string:替换后,产生的新串
**************************************************/
Sequential_string Replace_Sequential_String(Sequential_string old_string, int begin_loation,int number,Sequential_string replace_string)
{
    int counter;
    Sequential_string new_string;
    new_string.length = 0;
    //合法性判断
    if(begin_loation <= 0 || begin_loation > old_string.length || begin_loation+number-1>old_string.length)
    {
        //错误:要替换位置出现错误
        printf("\nError<9>: There is an error in the position to be replaced.\n");
        return new_string;//返回空串
    }
    //开始复制剪切
    for(counter = 0; counter < begin_loation-1; counter++)
    {
        new_string.Sequential_string_data[counter] = old_string.Sequential_string_data[counter];
    }
    //加入要替换的串
    for(counter = 0; counter < replace_string.length; counter++)
    {
        new_string.Sequential_string_data[begin_loation-1+counter] = replace_string.Sequential_string_data[counter];
    }
    //被替换位置,后面剩余的串
    for(counter = begin_loation+number-1; counter < old_string.length; counter++)
    {
        new_string.Sequential_string_data[counter-number+replace_string.length] = old_string.Sequential_string_data[counter];
    }
    new_string.Sequential_string_data[counter-number+replace_string.length] = '\0';
    new_string.length = old_string.length - number + replace_string.length;
    return new_string;
}



/**************************************************
(10)函数名: Display_Sequential_String
功  能: 输出展示串
参  数: Sequential_string show_String:要输出展示的串
注  意: 字符串后续可以换成自定义类型
返回值: 无
**************************************************/
void Display_Sequential_String(Sequential_string show_String)
{
    int counter;
    if(show_String.length > 0)
    {
        for(counter = 0; counter < show_String.length; counter++)
        {
            printf("%c", show_String.Sequential_string_data[counter]);
        }
        printf("\n");
    }
}

main函数调用

int main()
{
    //在母串里面找子串
    Sequential_string Mother_String;
    Sequential_string Son_String;

    char Mother_String_array[] = {'a','b','a','b','c','a','b','c','a','c','b','a','b','\0'};
    char Son_String_array[] = {'a','b','c','a','c','\0'};
    //把两个字符串创建成字符串
    Assignment_Sequential_string(Mother_String, Mother_String_array);
    Assignment_Sequential_string(Son_String, Son_String_array);
    printf("\nMother_String:\n");

    Display_Sequential_String(Mother_String);
    printf("\nSon_String:\n");
    Display_Sequential_String(Son_String);
    printf("\n%d\n",Find_matching_location(Mother_String,Son_String));

    return 0;
}

main.cpp源码(包含功能函数)

main.cpp
#include <stdio.h>
#include "Sequential_string.h"

/**************************************************
函数名: Find_matching_location
功  能: 利用B-f算法,寻找子串在母串中的位置
参  数: (1)Sequential_string Mother_String:母串
        (2)Sequential_string Son_String:子串
思  路:  从开始逐个对比,如果对比不成功, 则起始位置前移, 计数器初始化, 直到超出长度或找到
注  意:   我们判断是否找到的标志,就是判断 子串计数器是否对比完,然后跳出
返回值:  int: -1--没找到, 其他:找到,返回其数组位序
**************************************************/
int Find_matching_location(Sequential_string Mother_String,Sequential_string Son_String)
{
    int Mother_counter,Son_counter;//同步计数器
    int Mother_begin;//每次对比从母串开始的位置
    Mother_counter = 0;
    Son_counter = 0;
    Mother_counter = 0;
    //Brute-Force算法
    while((Mother_begin+Mother_counter) < Mother_String.length && Son_counter < Son_String.length)
    {
        if(Mother_String.Sequential_string_data[Mother_begin+Mother_counter] == Son_String.Sequential_string_data[Son_counter])
        {
            Mother_counter++;
            Son_counter++;
        }
        else
        {
            Mother_begin++;
            Mother_counter = 0;
            Son_counter = 0;
        }
    }
    //通过判断子串计数器的溢出数值,得出是否找到
    if(Son_counter >= Son_String.length)
    {
        return Mother_begin;
    }
    else
    {
        return (-1);
    }
}


int main()
{
    //在母串里面找子串
    Sequential_string Mother_String;
    Sequential_string Son_String;

    char Mother_String_array[] = {'a','b','a','b','c','a','b','c','a','c','b','a','b','\0'};
    char Son_String_array[] = {'a','b','c','a','c','\0'};
    //把两个字符串创建成字符串
    Assignment_Sequential_string(Mother_String, Mother_String_array);
    Assignment_Sequential_string(Son_String, Son_String_array);
    printf("\nMother_String:\n");

    Display_Sequential_String(Mother_String);
    printf("\nSon_String:\n");
    Display_Sequential_String(Son_String);
    printf("\n%d\n",Find_matching_location(Mother_String,Son_String));

    return 0;
}

运行结果展示:

无数碎片寻你
关注
  • 16
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
串的模式匹配算法-BF（Brute-Force）算法
[SZU_Crayon]
05-20 1831
Bruce-Force算法     1.思路：        简单暴力的一个算法，如果遇到字符不匹配，主串i指针回溯到本次匹配位置的下一个位置，而模式串则重新回到0（开始的位置），开始下一轮的匹配。         成功匹配的条件自然事模式串指针j走到头，也就是j=length-1，length为模式串长度。跳出循环表示为j=length     2.算法复杂度        O（n*m...
Java数据结构及算法实例：朴素字符匹配 Brute Force
09-03
朴素字符匹配，也称为Brute Force算法，是一种基础的字符串搜索方法。它的基本思想是对每一对主串（待查找的字符串）和模式串（要匹配的子串）进行逐字符的比较，直到找到匹配的子串或者遍历完所有可能的起始位置。...
Brute-Force模式匹配算法
初心不忘、始终方得
05-14 1747
Brute-Force模式匹配算法的详解与实现案例
【算法】Brute-Force 算法
代码星辰的博客
02-01 2226
本文介绍字符串的模式匹配算法之一——Brute-Force 算法，包括其概述、代码实现等。
33、串的模式匹配－Brute-Force算法
hopegrace的博客
03-03 1036
一、与串相关的概念 1、串（或字符串）是由零个或多个字符组成的有限序列。一般记作：s=〃c0c1c2…cn-1〃(n≥0)。零个字符的串称为空串，通常以两个相邻的双引号来表示空串，仅由空格组成的的串称为空格串，如：s=〃〃； 2、串与线性表的异同。字符串一般简称为串，可以将它看作是一种特殊的线性表，这种线性表的数据元素的类型总是字符型的，字符串的数据对象约束为字符集。在线性表的基本操...
C++实现字符串匹配的暴力算法
01-09
蛮力法（Brute Force Algorithm）是最基础的字符串匹配方法，其基本思想是对每个可能的子串进行比较，直到找到匹配的子串或者遍历完所有子串。 **代码实现**： ```cpp #include #include using namespace std; ...
字符串的模式匹配详解--BF算法与KMP算法
09-04
本文主要探讨两种经典的模式匹配算法：BF（Brute Force，暴力匹配）算法和KMP（Knuth-Morris-Pratt，克努斯-莫里斯-普拉特）算法。 **BF算法**是最基础的模式匹配方法，它的核心思想是对每一个可能的子串进行匹配...
数据结构-串的模式匹配算法（Java实现）
11-27
编程实现如下功能： 1、在实验六的基础上，实现串的Brute-Force模式匹配算法。 2、尝试实现串的KMP模式匹配算法。
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 876
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 180
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 329
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法-KMP字符串匹配
xx_xb的博客
07-23 262
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
2766. 重新放置石块 Medium
珞米的博客
07-24 504
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 253
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法题目整合5
qq_62571233的博客
07-23 910
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
贪心加暴力枚举
wniuniu_的博客
07-24 212
所以我们可以直接暴力枚举，然后我们知道假操作一定是在最开始进行，至于加多少次我们可以直接枚举。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 310
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
2022机器人障碍物检测算法
06-06
针对机器人障碍物检测问题，目前有许多算法可供选择，以下是几种常见的算法： 1. 基于深度学习的算法：如基于卷积神经网络（CNN）的YOLO（You Only Look Once）算法、基于Mask R-CNN的算法等，这些算法利用深度学习模型对图像进行特征提取和分类，能够快速准确地检测出障碍物。 2. 基于激光雷达的算法：利用激光雷达扫描周围环境，获取点云数据，然后通过点云数据分析和处理，检测出障碍物，如基于激光雷达的SLAM（Simultaneous Localization and Mapping）算法、ICP（Iterative Closest Point）算法等。 3. 基于视觉的算法：利用摄像头获取图像，通过图像分析和处理，检测出障碍物，如基于视觉的SURF（Speeded Up Robust Feature）算法、基于视觉的HOG（Histogram of Oriented Gradients）算法等。 以上算法各有优劣，可以根据具体应用场景和需求选择适合的算法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值