3月24日 想到了一个字符串匹配的新算法 程序 时间复杂度自己不会算

最新推荐文章于 2022-05-08 18:45:25 发布
最新推荐文章于 2022-05-08 18:45:25 发布
阅读量1.5k 收藏
点赞数
分类专栏： 日记 文章标签： 算法 null struct c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/uuty/article/details/329431
版权

/***********************************************************************
 * 字符串匹配  uty@uaty
 * 算法:先将待搜索串中每个字符出现的位置录入链表数组ANSI,字符的ASCII值既为
 *      数组的index,当同一个字符出现多于一次,对应链表增加一个节点
 *      匹配时,用目的字符串的每个字符作为索引找出其所在待搜索串的位置
 *      ,若各所在位置的值存在依次递增1情况,说明目的字串出现在待搜索串中
 ***********************************************************************/
#include <stdio.h>
#include <windows.h>
DWORD lookupthesource(char *source,int length);
DWORD dotheseArching(char* str,int length);
BOOL hAvenext(char chAr,int position);

typedef struct _node
{
 int    vAlue;//在待搜索串中的位置
 struct _node* next;
 BOOL   isnext;//该字符所在位置是目的串中的一个字符的下一个
}NODE,*PNODE;
PNODE ANSI[256];
//--------------------------------------------------------------------
DWORD main(void)
{
 char sourcestring[1024] = "AABBCCDFFFFC";
 char seArching[1024] = "B";
 int  i;
 int  ret;
 for (i = 0;i<256;i++) ANSI[i] = NULL;

 lookupthesource(sourcestring,1024);//将待搜索串中每个字符出现的位置录入链表数组ANSI
 ret = dotheseArching(seArching,strlen(seArching));//匹配过程
 printf("%s/n%s/n",sourcestring,seArching);
 printf("%d/n",ret);
 return 0;
}
//--------------------------------------------------------------------
DWORD lookupthesource(char *source,int length)
{
 int  i;
 PNODE temp;
 for (i = 0; i <length; i++){
  if (ANSI[source[i]] == NULL){
   ANSI[source[i]] = (PNODE)malloc(sizeof(NODE));
   ANSI[source[i]]->vAlue = i;
   ANSI[source[i]]->next = NULL;
   ANSI[source[i]]->isnext = FALSE;

  }
  else{
   for (temp = ANSI[source[i]];temp->next != NULL;temp = temp->next );
   temp->next = (PNODE)malloc(sizeof(NODE));
   temp->next->vAlue = i;
   temp->next ->next = NULL;
   temp->next ->isnext = FALSE;
  }
 }
 return 0;
}
//--------------------------------------------------------------------
DWORD dotheseArching(char* str,int length)
{
 int   i;
 PNODE  temp;
 for (i = 0;i < length  ;i++){//length -1 ?
  //next = 0;
  for (temp = ANSI[str[i]];temp != NULL;temp = temp->next ){
   if (length == 1) return temp->vAlue ;//考虑目的串只有一个字符的时候情况特殊
   if (i == 0 || temp->isnext == TRUE){//目的串的第一个字符的isnext为FALSE
    if (hAvenext(str[i + 1],temp->vAlue + 1) && i+1 == length -1){//是否当前字
                 //符在待查找串中位置的下一个字符是该字符在目的串中的下一个
     return (temp->vAlue + 1 - (length-1));//这样只能返回第一个找到的位置
    // temp->vAlue + 1  当前字符是第length-1个; return目的串第一个字符出现的位置
    }  
   }
  }
 }
 return -1;
}
//--------------------------------------------------------------------
BOOL hAvenext(char chAr,int position)
{
 PNODE  temp;
 for (temp = ANSI[chAr];temp != NULL;temp = temp->next ){
  if (temp->vAlue == position){
   temp->isnext = TRUE;
   return TRUE;
  }
  if (temp->vAlue > position) return FALSE;//链表节点按字符出现先后顺序
 }
 return FALSE;
}
//--------------------------------------------------------------------

有问题，换个新的，，效率不很好，还可再提

/***********************************************************************
 * 字符串匹配  uty@uaty
 * 算法:先将待搜索串中每个字符出现的位置录入链表数组ANSI,字符的ASCII值既为
 *      数组的index,当同一个字符出现多于一次,对应链表增加一个节点
 *      匹配时,用目的字符串的每个字符作为索引找出其所在待搜索串的位置
 *      ,若各所在位置的值存在依次递增1情况,说明目的字串出现在待搜索串中
 ***********************************************************************/
#include <stdio.h>
#include <windows.h>
DWORD lookupthesource(char *source,int length);
DWORD dotheseArching(char* str,int length,char* sourcestring);
BOOL hAvenext(char chAr,int position);

typedef struct _node
{
 int    vAlue;//在待搜索串中的位置
 struct _node* next;
 BOOL   isnext;//该字符所在位置是目的串中的一个字符的下一个
}NODE,*PNODE;
PNODE ANSI[256];
//--------------------------------------------------------------------
DWORD main(void)
{
 //"dsfserwfgdfgertertertreterterrrrrrrrrrrrrrrrrtrertfgdfgdfgddd""fgdfgd"
 char sourcestring[1024] = "AAAAAAAABBDEAAAAAAAAAAAAAAAAAAAAAAA";
 char seArching[1024] = "ABBDE" ;
 int  i;
 int  ret;
 for (i = 0;i<256;i++) ANSI[i] = NULL;

 for (i = 0;i<strlen(sourcestring);i++){
  printf("%c",sourcestring[i]);
  if ((i+1) % 10 == 0) printf(" ");
 }
 printf("/n");
 printf("%s/n",seArching);
 lookupthesource(sourcestring,1024);//将待搜索串中每个字符出现的位置录入链表数组ANSI
 ret = dotheseArching(seArching,strlen(seArching),sourcestring);//匹配过程
 printf("%d/n",ret);
 return 0;
}
//--------------------------------------------------------------------
DWORD lookupthesource(char *source,int length)
{
 int  i;
 PNODE temp;
 for (i = 0; i <length; i++){
  if (ANSI[source[i]] == NULL){
   ANSI[source[i]] = (PNODE)malloc(sizeof(NODE));
   ANSI[source[i]]->vAlue = i;
   ANSI[source[i]]->next = NULL;
   ANSI[source[i]]->isnext = FALSE;

  }
  else{
   for (temp = ANSI[source[i]];temp->next != NULL;temp = temp->next );
   temp->next = (PNODE)malloc(sizeof(NODE));
   temp->next->vAlue = i;
   temp->next ->next = NULL;
   temp->next ->isnext = FALSE;
  }
 }
 return 0;
}
//--------------------------------------------------------------------
DWORD dotheseArching(char* str,int length,char* sourcestring)
{
 int   i;
 PNODE  temp;
 for (i = 0;i < length  ;i++){//length -1 ?
  //next = 0;
  for (temp = ANSI[str[i]];temp != NULL;temp = temp->next ){
   if (length == 1) return temp->vAlue ;//考虑目的串只有一个字符的时候情况特殊
   if (i == 0 || temp->isnext == TRUE){//目的串的第一个字符的isnext为FALSE
    if ( hAvenext(str[i + 1],temp->vAlue + 1) && i+1 == length -1){//是否当前字
                 //符在待查找串中位置的下一个字符是该字符在目的串中的下一个
     if (0 == strncmp((sourcestring+(temp->vAlue + 1 - (length-1))),str,length)){
      return (temp->vAlue + 1 - (length-1));//这样只能返回第一个找到的位置
      //printf("%d/n",temp->vAlue + 1 - (length-1));
     }
     //printf("%d/n",temp->vAlue + 1 - (length-1));
    // temp->vAlue + 1  当前字符是第length-1个; return目的串第一个字符出现的位置
    }  
   }
  }
 }
 return -1;
}
//--------------------------------------------------------------------
BOOL hAvenext(char chAr,int position)
{
 PNODE  temp;
 for (temp = ANSI[chAr];temp != NULL;temp = temp->next ){
  if (temp->vAlue == position){
   temp->isnext = TRUE;
   return TRUE;
  }
  if (temp->vAlue > position) return FALSE;//链表节点按字符出现先后顺序
 }
 return FALSE;
}
//--------------------------------------------------------------------

uuty
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
字符串匹配算法（Brute-Force）
Mr_Dai的博客
09-12 5793
      Brute-Force匹配算法是比较容易理解的字符串匹配算法，时间复杂度为O(M*N)，为了更加清晰的理解该算法，我先来举个例子先。        字符串 text = "abgdbcfg";        字符串 str = “bcf”；        判断text中是否包含bcf，text中的第一位a与str中的第一位b相比不相等，text移到第二位b与str中的第一位b相等...
串的模式匹配算法
QS_Sun_24的博客
04-06 1212
模式匹配是在主串（也称目标串）中，从给定的起始位start开始查找是否存在我们需要的子串（也称模式串），如果查找成功返回模式串的第一个字符在主串中的位置，当模式匹配失败，返回-1。常用的模式匹配算法有Brute_Force算法和KMP算法。 Brute_Force算法，从force就可以看出是一种蛮力解决的方法。其模式匹配思想是：（1）将模式串的第一个字符与主串的第一个字符对齐放置，比较第一个字
KMP字符串模式匹配详解
sms88的专栏
11-25 1904
KMP字符串模式匹配详解             KMP字符串模式匹配详解             KMP字符串模式匹配详解                                                     来自CSDN     A_B_C_ABC 网友                                                     来自CSDN   
字符串匹配KMP算法及其时间复杂度分析
qq_36665989的博客
10-09 3699
   字符串匹配算法是非常常见的算法。考虑长度为nnn的文本（text）字符串A[1,2,⋯ ,n]A[1,2,\cdots,n]A[1,2,⋯,n]，长度为mmm的匹配（pattern）字符串B[1,2,⋯ ,m]B[1,2,\cdots,m]B[1,2,⋯,m]，并且m≤nm\leq nm≤n。暴力求解（brute-force）的匹配算法十分直接。将BBB逐位与AAA进行对比，直到BBB完全匹配AAA的某个子串。例如，先拿BBB与A[1,2,⋯ ,m]A[1,2,\cdots,m]A[1,2,⋯,m]匹
字符串模式匹配算法——BM、Horspool、Sunday、KMP、KR、AC算法一网打尽
qiudesuo的专栏
10-18 3873
字符串模式匹配算法——BM、Horspool、Sunday、KMP、KR、AC算法一网打尽     本文内容框架： §1 Boyer-Moore算法 §2 Horspool算法 §3 Sunday算法 §4 KMP算算法 §5 KR算法 §6 AC自动机 §7 小结    §1 Boyer-Moore（BM）算法   Boyer-Moore算法原理   Boye...
字符串匹配算法
尚墨1111的博客
08-12 1430
字符串匹配算法 此算法通常输入为原字符串（string）和子串（pattern），要求返回子串在原字符串中首次出现的位置。比如原字符串为“ABCDEFG”，子串为“DEF”，则算法返回3。 BF（Brute Force，暴力检索） KMP（教科书上最常见算法） BM（Boyer Moore） RK（Robin-Karp，哈希检索） Sunday算法 暴力检索 首先将匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位。速度最慢。 时间复杂度：O（m*n） /** *
"字符串柯尔莫哥洛夫复杂度近似理论及应用
x的c-短程序是一个字符串p，使得U（p）=x，p的长度以c+（x的最短程序的长度）为界 我们表明，对于任何标准的图灵机，有可能在多项式时间内计算输入x的多项式大小的列表，保证包含O log |X|-x的短程序。 我们还证明了...
编写一个python程序、输出如下语句_Python 入门习题
weixin_39812577的博客
12-04 6891
如果下面代码有问题或者你有更好的实现方法欢迎与我私信~1、输入一个字符串，内容是带小数的实数，例如"123.45"，输出是两个整数变量x和y，x是整数部分123，y是小数部分45。你可以用split函数完成。str =input()L=str.split(".") #此函数可以将输入的小数部分的.符号最后消除，并用，号代替分割整数和小数L=[int(e) for e in L] #分割后依...
柯尔莫哥洛夫复杂度的列表近似器的研究
x的c-短程序是一个字符串p，使得U（p）=x，p的长度以c+（x的最短程序的长度）为界 我们表明，对于任何标准的图灵机，有可能在多项式时间内计算输入x的多项式大小的列表，保证包含O log |X|-x的短程序。 我们还证明了...
基于音形码的中文字符串相似度算法(转)
bianchengjingling22的博客
05-07 1242
基于音形码的中文字符串相似度算法(转) 转自 【https://blog.csdn.net/chndata/article/details/41114771】 字符串相似度算法是指通过一定的方法，来计算两个不同字符串之间的相似程度。通常会用一个百分比来衡量字符串之间的相似程度。字符串相似度算法被应用于许多计算场景，在诸如数据清洗，用户输入纠错，推荐...
字符串匹配的KMP算法
颤抖的羽翼
01-27 466
字符串匹配是计算机的基本任务之一。 举例来说，有一个字符串"BBC ABCDAB ABCDABCDABDE"，我想知道，里面是否包含另一个字符串"ABCDABD"？ 许多算法可以完成这个任务，Knuth-Morris-Pratt算法（简称KMP）是最常用的之一。它以三个发明者命名，起头的那个K就是著名科学家Donald Knuth。 这种算法不太容易理解，网上有很多解释，但读起来都很
极客时间——数据结构与算法（34）：字符串匹配基础（下）：如何借助BM算法轻松理解KMP算法？
weixin_40805079的博客
03-05 247
转载地址：https://time.geekbang.org/column/article/71845 上一节我们讲了 BM 算法，尽管它很复杂，也不好理解，但却是工程中非常常用的一种高效字符串匹配算法。有统计说，它是最高效、最常用的字符串匹配算法。不过，在所有的字符串匹配算法里，要说最知名的一种的话，那就非 KMP 算法莫属。很多时候，提到字符串匹配，我们首先想到的就是 KMP 算法。 尽管...
字符串匹配之BF和RK算法
抱愚守拙，持之以恒；不问结果，相信过程.
09-30 626
单模式串匹配算法：BF+RK
六种字符串匹配算法详解（含代码演示）
Guqing_f的博客
05-08 6659
1. Brute-Force算法 2. Rabin-Karp Hash算法 3. Kmp算法 4. Kmp的优化算法 5. Sunday算法 6. Shift-And算法 ps：字符串匹配其实是单模匹配问题 1.Brute-Force 朴素匹配算法（暴力匹配） 时间复杂度：O(n*m) //返回 文本串s中第一次查找到模式串t的位置 int brute_force(const char *s, const char *t){ //扫描文本串的每一位 for(int i = 0; s[i];
KMP算法——字符串匹配及其应用 时间复杂度O(M+N) 空间复杂度O(N)
Go的全部
11-06 1893
package kmp import ( "strconv" "strings" "testing" ) /* /* Knuth-Morris-Pratt算法（简称KMP），是由D.E.Knuth、J.H.Morris和V.R.Pratt共同提出的一个改进算法，消除了朴素的模式匹配算法中回溯问题，完成串的模式匹配。 算法思想： 设目标串为s，模式串为t， i、j 分别为指示s和t的指针，i、j的初值均为0。 若有 si = tj，则i和j分别增1；否则，i不变，j退回至j=next[j]的位置
关于面试高频问题之--字符串匹配问题
Yangchenju的博客
08-01 1118
字符串匹配问题是面试的高频问题之一，本文讲字符串和它的相关操作。 1. 字符串是什么 字符串（string） 是由 n 个字符组成的一个有序整体（ n >= 0 ）。例如，s = “BEIJING” ，s 代表这个串的串名，BEIJING 是串的值。这里的双引号不是串的值，作用只是为了将串和其他结构区分开。字符串的逻辑结构和线性表很相似，不同之处在于字符串针对的是字符集，也就是字符串中的元素都是字符，线性表则没有这些限制。 在实际操作中，我们经常会用到一些特殊的字符串： s = ""; // 表示空
【算法与数据结构 08】字符串 —— 字符串匹配算法（面试高频考点！）
不积跬步，无以至千里！
09-03 3529
小白专属的《算法与数据结构》，夯实基础，直击面试！
算法笔记：简单的字符串模式匹配-KMP算法（与BF算法对比时间复杂度）
RToax
04-21 3272
简单的讲就是字符串不回溯。#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; int countBF = 0; int countKMP = 0; int BF(char *A, char *a) { printf("\n-------BF-------\n"); int j = 0, i = ...
字符串匹配蛮力算法和kmp算法的时间复杂度
最新发布
12-06
字符串匹配蛮力算法的时间复杂度为O(m*n)，其中m为模式串的长度，n为主串的长度。具体实现是从主串的第一个字符开始，依次和模式串的每一个字符进行比较，如果匹配失败，则主串的指针后移一位，重新开始匹配。这种算法的缺点是效率低下，当模式串和主串长度较大时，时间复杂度会非常高。 KMP算法的时间复杂度为O(m+n)，其中m为模式串的长度，n为主串的长度。KMP算法的核心思想是利用已经匹配过的信息，尽量减少模式串和主串的匹配次数。具体实现是通过预处理模式串，得到一个next数组，用于指导匹配过程中的跳转。在匹配过程中，如果匹配失败，则根据next数组的值，将模式串的指针移动到合适的位置，继续匹配。这种算法的优点是时间复杂度低，适用于模式串和主串长度较大的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值