字符串匹配算法----暴力算法（Brute&Force&algorithm
字符串匹配算法----暴力算法（Brute Force
algorithm）
暴力算法是字符串匹配算法中最简单的算法
暴力算法就是文本串每次移动向右移动一个字符，与模式串比较，如果每个字符都相等，则表示在文本串中找到与模式串匹配的子集。
暴力算法的时间复杂度为O(mn)（m、n分别为文本串和模式串的长度）。无需扩展存储空间。
算法实现如下：
1、普通算法
//输出所有匹配子串的位置
void BFSearchPatternInText(const char* s, int m, const char* d,
for(i = 0; i&&= m-n; ++i)
for(j = 0; j &&n
&& d[j] == s[i+j]; ++j);
if(j &= n&)
OUTPUT(i);
2、改进算法
//输出所有匹配子串的位置
void BFSearchPatternInText(const char* s, int m, const char* d,
const char *ss =
while(s - ss &= m -n)
if(memcmp(s++, d, n) == 0)
OUTPUT(s - ss);
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。字符串匹配暴力算法 与 字符串匹配的KMP算法
声明：先看一下阮一峰的网络日志关于字符串的KMP算法的讲解。本文图片均引用于这篇日志。
在先前的笔试中遇到了关于字符串匹配的问题，一时脑袋卡壳没写好算法。现在就来分析分析
暴力算法和KMP算法各自原理，以及代码实现，之间差异，并且总结一下好算法的一般思路。
===========================================================================
各自原理：
暴力算法：
我们把长的字符串做为一个文本字符串，命名为strText，把短的字符串称为目标串，命名为strTarget。
文本串&BBC ABCDAB ABCDABCDABDE&的第一个字符&B&与目标串&ABCDABD&的第一个字符&A&
比较不产生匹配，在整个过程中，我们假设红色虚线是固定的。因此，文本串向左边移动一个字符。
字符&B&与&A&不产生匹配，文本串继续左移。
直到这里，此时出现第一个匹配，程序中将文本串和目标串都向左移动，并且记录下此时文本串出来比较
的那个元素（就是字符&A&）的位置。
继续比较，又是一个匹配，继续移动。
此时出现不匹配，比较重新归位，根据前面记录的&A&的位置文本串进入下一个字符&B&，而目标串的下标重新开始，
继续比较。
这个就是暴力算法的大致原理分析过程。
代码实现：
SViolence( const char strText[ ], const char strSearch[ ] )
int lengthOfstrText, lengthOfstrS
lengthOfstrText = strlen( strText );
lengthOfstrSearch = strlen( strSearch );
/*for( i = 0, j = 0, ii = 0; i & lengthOfstrText && j & lengthOfstrS )*/
for( i = 0, j = 0, ii = 0; j & lengthOfstrS )
if( strText[ i ] == strSearch[ j ] )
j = 0;/* make a clear */
if( j == lengthOfstrSearch )
printf( &Existence!& );
printf( &No Existence!& );
在程序中的ii变量就是记录位置的。理解这个算法的运行过程可以很清楚的知道在算法中做了很多重复的比较工作。
时间复杂度分析：咋一看这个程序感觉很（hen）快（man）啊，只有一个for循环而已嘛。呵呵，其实你有所不知，这个for循环与众不同，它的结束不只是依赖于for循环条件而已，而是有循环条件和循环体的i，j，ii，等变量共同决定的。我们记lengthOfText = m，lengthOfSearch = n；所以这个算法的时间复杂度大概为：T( n )= O( m * n )这个级别已经是我们所唾弃的了。
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'KMP子字符串查找算法
KMP子字符串查找算法
KMP子字符串查找算法
算法的基本思想是：当出现不匹配时，就能知晓一部分文本的内容，可以利用这些信息避免将指针回退到所有这些已知的字符串之前。
DFA（确定有限状态机）模拟
提前判断如何重新查找，而这种判断只取决于模式本身，所以可以对模式的字符序列做一个确定有限状态机。
DFA的数据结构表示为二维数组dfa[R][M]，其中R为指定字典中的字符集的个数（比如ASCII为256），M为匹配字符串pat的长度，状态的意思是文本中某个位置i匹配pat的程度，0状态为未匹配状态，M状态为终止状态，找到了完整匹配的字符串。
如图中R=3，M=6，二维数组中的值指向下一个状态。
穷举模式pat的所有可能情况，将这些情况用状态图表示。其中X记录匹配失败时重启的索引位置。
用暴力算法实现子字符串查找算法
public int search(String txt, String pat) {
int i, N = txt.length();
int j, M = pat.length();
for (i = 0, j = 0; i & N && j & M; i++) {
if (txt.charAt(i) == pat.charAt(j)) {
if (j==M) return i-M;
* pat在txt中开始出现的位置，如果等于txt.length()表示没有找到
public int search(String txt) {
int M = pat.length();
int N = txt.length();
for (i = 0, j = 0; i & N && j & M; i++) {
j = dfa[txt.charAt(i)][j];
if (j == M) return i - M;
private final int R;
private int[][]
public KMP(String pat) {
this.R = 256;
this.pat =
int M = pat.length();
dfa = new int[R][M];
dfa[pat.charAt(0)][0] = 1;
for (int X = 0, j = 1; j & M; j++) {
for (int c = 0; c & R; c++) {
dfa[c][j] = dfa[c][X];
dfa[pat.charAt(j)][j] = j + 1;
X = dfa[pat.charAt(j)][X];
优点：适合在长度不确定的输入流中进行查找，不需要在输入中回退。
缺点：最坏的情况（在重复性很高的文本中查找重复性很高的模式）在实际应用中很少出现，还不如使用暴力算法来的容易，性能也差不了多少。
我的热门文章
即使是一小步也想与你分享Java的字符串中对子字符串的查找方法总结
作者：iceFin
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了Java的字符串中对子字符串的查找方法总结,是Java入门学习中的基础知识,需要的朋友可以参考下
Java中字符串中子串的查找共有四种方法，如下：
1、int indexOf(String str) ：返回第一次出现的指定子字符串在此字符串中的索引。
2、int indexOf(String str, int startIndex)：从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。
3、int lastIndexOf(String str) ：返回在此字符串中最右边出现的指定子字符串的索引。
4、int lastIndexOf(String str, int startIndex) ：从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。
indexof()用法说明
返回 String 对象内第一次出现子字符串的字符位置。
string.indexOf(subString[, startIndex])
必选项。String 对象或文字。
subString 必选项。
要在 String 对象中查找的子字符串。
starIndex 可选项。
该整数值指出在 String 对象内开始查找的索引。如果省略，则从字符串的开始处查找。
indexOf 方法返回一个整数值，指出 String 对象内子字符串的开始位置。如果没有找到子字符串，则返回-1。
如果 startindex 是负数，则 startindex 被当作零。如果它比最大的字符位置索引还大，则它被当作最大的可能索引。
从左向右执行查找。否则，该方法与 lastIndexOf 相同。
下面的示例说明了 indexOf 方法的用法。
function IndexDemo(str2){
var str1 = "BABEBIBOBUBABEBIBOBU"
var s = str1.indexOf(str2);
return(s);
java查找字符串中的包含子字符串的个数
1.用indexof的方法：
public class Test11
private static int counter = 0;
* @param args
public static void main(String[] args)
String str ="sdSS**&HGJhadHCASch& ^^";
int i = stringNumbers(str);
System.out.println(i);
public static int stringNumbers(String str)
if (str.indexOf("java")==-1)
else if(str.indexOf("java") != -1)
counter++;
stringNumbers(str.substring(str.indexOf("java")+4));
2.如果子字符串不是一个首尾相同的字符串，还可以这样实现：
if(str.indexOf("java") != -1)
String[] str1 = str.split("java");
System.out.println(str1.length-1);
System.out.println(0);
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具改进的字符串查找算法_论文_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
您可以上传图片描述问题
联系电话：
请填写真实有效的信息，以便工作人员联系您，我们为您严格保密。
改进的字符串查找算法
||文档简介
中国最大最早的专业内容网站|
总评分0.0|
&&字​符​串​匹​配​效​率​的​提​高​。​能​够​带​来​入​侵​检​测​系​统​检​测​效​率​的​提​高​。​B​M​、​W​M​是​目​前​常​用​的​字​符​匹​配​算​法​,​从​这​些​算​法​中​结​合​数​理​统​计​抽​样​的​思​想​,​本​文​希​望​通​过​抽​样​检​测​的​方​式​提​高​匹​配​的​效​率​。​首​先​,​新​算​法​按​照​模​式​字​符​串​的​长​度​,​从​文​本​中​固​定​地​截​取​字​符​作​为​抽​样​点​;​其​次​,​判​断​该​抽​样​点​是​否​在​模​式​中​出​现​,​并​从​中​分​离​出​那​些​出​现​在​模​式​中​的​抽​样​点​。​最​后​,​在​分​离​出​的​抽​样​点​周​围​进​行​精​确​的​模​式
试读已结束，如果需要继续阅读或下载，敬请购买
定制HR最喜欢的简历
你可能喜欢