求比我写的这个POS函数更优化的函数(50分)

function FPos(Head, Source: string): Integer;
var
I, J, LenHead, PosHead, PosStart, LenSource: Integer;
begin
PosStart := 0;
LenSource := Length(Source);
LenHead := Length(Head);
if (LenSource = 0) or (LenHead = 0) then
begin
Result := 0;
Exit;
end;
for I := 1 to LenSource do
begin
for J := 0 to LenHead-1 do
begin
if Source[I+J] <> Head[J+1] then Break;
if J = LenHead-1 then
begin
Result := I;
Exit;
end;
end;
end;
end;
这个函数不用考虑中文，能尽量快就可以了。
不知道有没有DELPHI的POS快。

这个绝对是最快的：
http://fastcode.sourceforge.net/FastcodeFileDownloads/FastCode.Libraries-0.6.4.zip
其中的 FastcodePosUnit.pas 针对不同的 CPU 汇编指令优化，使用时利用 hook 无缝替换，只需要 uses FastCode 单元即可。

To Pascal:
你这个看不出快在那里，某种程度上还是超级慢。

用Delphi的Pos函数相对来说已经是很优化了。

确实没看出来快在哪儿，还是逐字符比较。

for I := 1 to LenSource do
begin
if Source = Head[1] then //加这一行，减少执行大堆循环
for J := 1 to LenHead-1 do
begin
***

其实就是再快也快不到哪去了。
如果再想快就是在循环上下功夫了

function FPos(Head, Source: string): Integer;
...
不知道有没有DELPHI的POS快。


你不知道，我也不知道呢。

TO LSUPER
HOOK无缝替换是什么意思，每次调用都要HOOK吗
如果每个字符串不长，但调用次数多了会不会影响速度。
因为我每次查找的的母串不长，只有几百字节，但会
大量调用POS，在不同的母串中查找。

根据kinneng的思路，我又改进了一下，
并想了一个很好的方法，如下：

function FPos(Head, Source: string): Integer;
var
I, J, LenHead, PosHead, PosStart, LenSource: Integer;
Head1, Head2, HeadEnd: char;
begin
PosStart := 0;
LenSource := Length(Source);
LenHead := Length(Head);
if (LenSource = 0) or (LenHead = 0) then
begin
Result := 0;
Exit;
end;
Head1 := Head[1];
Head2 := Head[2];
HeadEnd := Head[LenHead];
for I := 1 to LenSource do
begin
if (Source = Head1) and
(Source[I+LenHead-1] = HeadEnd) and
(Source[I+1] = Head2) then
for J := 2 to LenHead-2 do
begin
if Source[I+J] <> Head[J+1] then Break;
if J = LenHead-2 then
begin
Result := I;
Exit;
end;
end;
end;
end;

此方法先判断子串Head的第一，二，尾三个字节是否满足
满足相等再对Head的中间部份详细判断。
用and 的好处是利用Delphi的 and 短路判断，就比循环
中的Break效率高。这样就避免了大量的二重循环。
以上方法可以大大的避免“某种程度上还是超级慢”的情况了。
我编这个函数的目的是快速定位到像：<WORD>这样的子串
所以找到头尾都是<>的就很快。对用于网页的分析比较快。

当然也许DELPHI本身的优化结果也可能采用这此些方法，实际
编译出来的效果有待实测。

function PosEx(const SubStr, S: string
Offset: Cardinal = 1): Integer;
var
I,X: Integer;
Len, LenSubStr: Integer;
begin
if Offset = 1 then
Result := Pos(SubStr, S)
else
begin
I := Offset;
LenSubStr := Length(SubStr);
Len := Length(S) - LenSubStr + 1;
while I <= Len do
begin
if S = SubStr[1] then
begin
X := 1;
while (X < LenSubStr) and (S[I + X] = SubStr[X + 1]) do
Inc(X);
if (X = LenSubStr) then
begin
Result := I;
exit;
end;
end;
Inc(I);
end;
Result := 0;
end;
end;

看来计算机专业基础知识的普及还是大有必要的。

算法和数据结构里面对于子串匹配有专门的讨论，研究一下KMP算法吧。针对楼主
特定需求，如果要考虑大多数情况下的高效，最好对常见网页的内容做一下分析，
看看各种格式字符串的的分布，有了这个数据就可以对算法的平均时间复杂性进行
定量分析了。

看谁有我快
//最短代码,最快的字符串定位程序 by jhd //
function comp(s,d:string):integer ;
var
i,j:Integer ;
begin
Result:=0 ;
i:=length(s) ;
if i<>0 and i <=Length(d) then
begin
for j:=0 to Length(d)-i do
begin
if CompareMem(Pointer(integer(s)),Pointer(integer(d)+j),i) then
begin
Result:=i ;
Break ;
end ;
end ;
end ;
end ;

找了一个比较深入浅出的讲KMP算法的，还没看懂：

[转自 matrix67.com]KMP算法详解2007-03-16 09:54 如果机房马上要关门了，或者你急着要和MM约会，请直接跳到第六个自然段。

我们这里说的KMP不是拿来放电影的（虽然我很喜欢这个软件），而是一种算法。KMP算法是拿来处理字符串匹配的。换句话说，给你两个字符串，你需要回答，B串是否是A串的子串（A串是否包含B串）。比如，字符串A="I'm matrix67"，字符串B="matrix"，我们就说B是A的子串。你可以委婉地问你的MM：“假如你要向你喜欢的人表白的话，我的名字是你的告白语中的子串吗？”
解决这类问题，通常我们的方法是枚举从A串的什么位置起开始与B匹配，然后验证是否匹配。假如A串长度为n，B串长度为m，那么这种方法的复杂度是O (mn)的。虽然很多时候复杂度达不到mn（验证时只看头一两个字母就发现不匹配了），但我们有许多“最坏情况”，比如，A= "aaaaaaaaaaaaaaaaaaaaaaaaaab"，B="aaaaaaaab"。我们将介绍的是一种最坏情况下O的算法（这里假设 m<=n），即传说中的KMP算法。
之所以叫做KMP，是因为这个算法是由Knuth、Morris、Pratt三个提出来的，取了这三个人的名字的头一个字母。这时，或许你突然明白了AVL 树为什么叫AVL，或者Bellman-Ford为什么中间是一杠不是一个点。有时一个东西有七八个人研究过，那怎么命名呢？通常这个东西干脆就不用人名字命名了，免得发生争议，比如“3x+1问题”。扯远了。
个人认为KMP是最没有必要讲的东西，因为这个东西网上能找到很多资料。但网上的讲法基本上都涉及到“移动(shift)”、“Next函数”等概念，这非常容易产生误解（至少一年半前我看这些资料学习KMP时就没搞清楚）。在这里，我换一种方法来解释KMP算法。

假如，A="abababaababacb"，B="ababacb"，我们来看看KMP是怎么工作的。我们用两个指针i和j分别表示，A[i-j+ 1..i]与B[1..j]完全相等。也就是说，i是不断增加的，随着i的增加j相应地变化，且j满足以A结尾的长度为j的字符串正好匹配B串的前 j个字符（j当然越大越好），现在需要检验A[i+1]和B[j+1]的关系。当A[i+1]=B[j+1]时，i和j各加一；什么时候j=m了，我们就说B是A的子串（B串已经整完了），并且可以根据这时的i值算出匹配的位置。当A[i+1]<>B[j+1]，KMP的策略是调整j的位置（减小j值）使得A[i-j+1..i]与B[1..j]保持匹配且新的B[j+1]恰好与A[i+1]匹配（从而使得i和j能继续增加）。我们看一看当 i=j=5时的情况。

i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7

此时，A[6]<>B[6]。这表明，此时j不能等于5了，我们要把j改成比它小的值j'。j'可能是多少呢？仔细想一下，我们发现，j'必须要使得B[1..j]中的头j'个字母和末j'个字母完全相等（这样j变成了j'后才能继续保持i和j的性质）。这个j'当然要越大越好。在这里，B [1..5]="ababa"，头3个字母和末3个字母都是"aba"。而当新的j为3时，A[6]恰好和B[4]相等。于是，i变成了6，而j则变成了 4：

i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7

从上面的这个例子，我们可以看到，新的j可以取多少与i无关，只与B串有关。我们完全可以预处理出这样一个数组P[j]，表示当匹配到B数组的第j个字母而第j+1个字母不能匹配了时，新的j最大是多少。P[j]应该是所有满足B[1..P[j]]=B[j-P[j]+1..j]的最大值。
再后来，A[7]=B[5]，i和j又各增加1。这时，又出现了A[i+1]<>B[j+1]的情况：

i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7

由于P[5]=3，因此新的j=3：

i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7

这时，新的j=3仍然不能满足A[i+1]=B[j+1]，此时我们再次减小j值，将j再次更新为P[3]：

i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 1 2 3 4 5 6 7

现在，i还是7，j已经变成1了。而此时A[8]居然仍然不等于B[j+1]。这样，j必须减小到P[1]，即0：

i = 1 2 3 4 5 6 7 8 9 ……
A = a b a b a b a a b a b …
B = a b a b a c b
j = 0 1 2 3 4 5 6 7

终于，A[8]=B[1]，i变为8，j为1。事实上，有可能j到了0仍然不能满足A[i+1]=B[j+1]（比如A[8]="d"时）。因此，准确的说法是，当j=0了时，我们增加i值但忽略j直到出现A=B[1]为止。
这个过程的代码很短（真的很短），我们在这里给出：

程序代码j:=0;for i:=1 to n dobegin while (j>0) and (B[j+1]<>A) do j:=P[j]
if B[j+1]=A then j:=j+1
if j=m then begin writeln('Pattern occurs with shift ',i-m)
j:=P[j]
end;end;

最后的j:=P[j]是为了让程序继续做下去，因为我们有可能找到多处匹配。
这个程序或许比想像中的要简单，因为对于i值的不断增加，代码用的是for循环。因此，这个代码可以这样形象地理解：扫描字符串A，并更新可以匹配到B的什么位置。

现在，我们还遗留了两个重要的问题：一，为什么这个程序是线性的；二，如何快速预处理P数组。
为什么这个程序是O的？其实，主要的争议在于，while循环使得执行次数出现了不确定因素。我们将用到时间复杂度的摊还分析中的主要策略，简单地说就是通过观察某一个变量或函数值的变化来对零散的、杂乱的、不规则的执行次数进行累计。KMP的时间复杂度分析可谓摊还分析的典型。我们从上述程序的j 值入手。每一次执行while循环都会使j减小（但不能减成负的），而另外的改变j值的地方只有第五行。每次执行了这一行，j都只能加1；因此，整个过程中j最多加了n个1。于是，j最多只有n次减小的机会（j值减小的次数当然不能超过n，因为j永远是非负整数）。这告诉我们，while循环总共最多执行了n次。按照摊还分析的说法，平摊到每次for循环中后，一次for循环的复杂度为O(1)。整个过程显然是O的。这样的分析对于后面P数组预处理的过程同样有效，同样可以得到预处理过程的复杂度为O(m)。
预处理不需要按照P的定义写成O(m^2)甚至O(m^3)的。我们可以通过P[1],P[2],...,P[j-1]的值来获得P[j]的值。对于刚才的B="ababacb"，假如我们已经求出了P[1],P[2],P[3]和P[4]，看看我们应该怎么求出P[5]和P[6]。P[4]=2，那么P [5]显然等于P[4]+1，因为由P[4]可以知道，B[1,2]已经和B[3,4]相等了，现在又有B[3]=B[5]，所以P[5]可以由P[4] 后面加一个字符得到。P[6]也等于P[5]+1吗？显然不是，因为B[ P[5]+1 ]<>B[6]。那么，我们要考虑“退一步”了。我们考虑P[6]是否有可能由P[5]的情况所包含的子串得到，即是否P[6]=P[ P[5] ]+1。这里想不通的话可以仔细看一下：

1 2 3 4 5 6 7
B = a b a b a c b
P = 0 0 1 2 3 ?

P[5]=3是因为B[1..3]和B[3..5]都是"aba"；而P[3]=1则告诉我们，B[1]和B[5]都是"a"。既然P[6]不能由P [5]得到，或许可以由P[3]得到（如果B[2]恰好和B[6]相等的话，P[6]就等于P[3]+1了）。显然，P[6]也不能通过P[3]得到，因为B[2]<>B[6]。事实上，这样一直推到P[1]也不行，最后，我们得到，P[6]=0。
怎么这个预处理过程跟前面的KMP主程序这么像呢？其实，KMP的预处理本身就是一个B串“自我匹配”的过程。它的代码和上面的代码神似：

程序代码P[1]:=0;j:=0;for i:=2 to m dobegin while (j>0) and (B[j+1]<>B) do j:=P[j]
if B[j+1]=B then j:=j+1
P:=j;end;

最后补充一点：由于KMP算法只预处理B串，因此这种算法很适合这样的问题：给定一个B串和一群不同的A串，问B是哪些A串的子串。

串匹配是一个很有研究价值的问题。事实上，我们还有后缀树，自动机等很多方法，这些算法都巧妙地运用了预处理，从而可以在线性的时间里解决字符串的匹配。我们以后来说。

Matrix67原创

怎么就没有一个汇编版？

要会汇编的话一定写一个，现在将就了。

vivadata1的方法就是kinneng说的那种，不过
Len := Length(S) - LenSubStr + 1;
这句能少搜索子串那么长；

Jhdandcl的函数内部调用了一个comparemem
在comparemem还是有一个循环，所以还是二重循环，还多了调用函数的时间

其实对于子串比较短的情况是用KMP反而慢了。我这个函数还要改进，改好了再贴上来。

目前经过实例验证最快的POS算法是BMH算法,子串长度<8时优势不明显,Pos<4时甚至还不如Delphi自带的Pos,但子串长度在20以上时,BMH的速度比KMP和FastCode都要快2~10倍以上.
BMH非常适合同一个子串在不同母串中匹配.尤其是不区分大小写的文本匹配.
KMP虽然名气大,但速度并不快....

KMP虽然名气大,但速度并不快....

{
Q_PosStr函数说明
参数：FindString，要查找的字符串
SourceString，源字符串
StartPos，从什么位置开始查找（所以，你可以用这个参数来查找下一个匹配的字符串）
返回值：如果找到了，返回找到的位置，否则，返回0
}
function Q_PosStr(const FindString, SourceString: string
StartPos: Integer): Integer;
asm
PUSH ESI
PUSH EDI
PUSH EBX
PUSH EDX
TEST EAX,EAX
JE @@qt
TEST EDX,EDX
JE @@qt0
MOV ESI,EAX
MOV EDI,EDX
MOV EAX,[EAX-4]
MOV EDX,[EDX-4]
DEC EAX
SUB EDX,EAX
DEC ECX
SUB EDX,ECX
JNG @@qt0
XCHG EAX,EDX
ADD EDI,ECX
MOV ECX,EAX
JMP @@nx
@@fr: INC EDI
DEC ECX
JE @@qt0
@@nx: MOV EBX,EDX
MOV AL,BYTE PTR [ESI]
@@lp1: CMP AL,BYTE PTR [EDI]
JE @@uu
INC EDI
DEC ECX
JE @@qt0
CMP AL,BYTE PTR [EDI]
JE @@uu
INC EDI
DEC ECX
JE @@qt0
CMP AL,BYTE PTR [EDI]
JE @@uu
INC EDI
DEC ECX
JE @@qt0
CMP AL,BYTE PTR [EDI]
JE @@uu
INC EDI
DEC ECX
JNE @@lp1
@@qt0: XOR EAX,EAX
@@qt: POP ECX
POP EBX
POP EDI
POP ESI
RET
@@uu: TEST EDX,EDX
JE @@fd
@@lp2: MOV AL,BYTE PTR [ESI+EBX]
CMP AL,BYTE PTR [EDI+EBX]
JNE @@fr
DEC EBX
JE @@fd
MOV AL,BYTE PTR [ESI+EBX]
CMP AL,BYTE PTR [EDI+EBX]
JNE @@fr
DEC EBX
JE @@fd
MOV AL,BYTE PTR [ESI+EBX]
CMP AL,BYTE PTR [EDI+EBX]
JNE @@fr
DEC EBX
JE @@fd
MOV AL,BYTE PTR [ESI+EBX]
CMP AL,BYTE PTR [EDI+EBX]
JNE @@fr
DEC EBX
JNE @@lp2
@@fd: LEA EAX,[EDI+1]
SUB EAX,[ESP]
POP ECX
POP EBX
POP EDI
POP ESI
int 21H
end;