线性表查找算法

第3章 线性表的查找算法

这里所说的查找，就是在一个给定的数据集合中搜素你指定的那个元素，查找的结果只能有两种：一种是找到所指定的元素，即查找成功，这时输出该元素在线性表中的位置信息；另一种结果是线性表中不存在该元素，宣告查找失败。

查找的方法很多，根据数据在表中的排列方式不同，可以选择不同的查找方法，其效率往往差别很大。本章，我们将分别叙述常用的几种查找方法。

3.1 顺序查找

顺序查找是最简单的查找方法，也是适应性最广的方法。它是从头开始，依次将表中的各个元素与指定的元素进行比较，直至在线性表中找到指定元素，输出位置信息，或者查遍整个线性表仍未找到而宣告失败。顺序查找算法非常直观简单，以字数据为例，程序流程图如图1所示，程序如下：

_________________________________________________________________________ //语法：

// C语言:

// int F_Find_In_Order(unsigned int Data_Addr,unsigned int Data_Length,

// unsigned int Value);

// 汇编:

// R1=[Data_Addr];

// R2=[Data_Length];

// R3=[Value];

// PUSH R1,R3 TO [SP];

// CALL F_Find_In_Order;

// [Find_Out]=R1

// POP R1，R3 FROM [SP]

//

//参数说明：Data_Addr：线性表首地址

// Data_Length：查找数据缓冲区的大小，即数据元素的个数

// Value：要查找的数据

//返回值: R1---查找到的对象

//破坏的寄存器:R1,R2,R3,R4

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// .IRAM

北阳电子内部技术资料

2 第一章 凌阳单片机简介

.PUBLIC G_Find_Flag;

.VAR G_Find_Flag=0; //查找结果标志单元，查找成功为1，反之为零

.CODE

.PUBLIC _F_Find_In_Order

.PUBLIC F_Find_In_Order

_F_Find_In_Order:

F_Find_In_Order: .PROC

PUSH BP,BP TO [SP];

BP=SP; //BP指向堆栈

BP+=4; //BP指向第一个参数位置

R4=[BP++]; //取线性表首址

R2=[BP++]; //取线性表元素个数

JZ L_Exit_Find_10; //为零，结束查找

R3=[BP]; //取查找对象

L_Find_Loop:

R1=[R4]; //取线性表中一个数据元素

CMP R3,R1; //比较数据元素和查找目标

JE L_Exit_Find_00; //是查找目标，查找结束

R4+=1; //不是查找目标，指向下一个数据元素

R2-=1; //数据元素减一

JNZ L_Find_Loop; //所有元素比较完吗？

R1=0 //返回值置零

[G_Find_Flag]=R1; //设置失败标志

JMP L_Exit_Find_10; //退出查找

L_Exit_Find_00:

R4=1; //设置成功标志

[G_Find_Flag]=R4;

L_Exit_Find_10:

POP BP,BP FROM [SP];

RETF

.ENDP

_________________________________________________________________________

- 2 -

第一章 凌阳单片机简介3

图1 无序线性表的顺序查找算法流程图

3.2折半查找

当线性表中的数据元素是无序排列时，只能采用顺序查找算法，不查完最后一个元素就不能判断线性表中没有这个元素，如果线性表先用排序算法进行过整理，成为有序线性表，则可以用折半查找算法来提高效率。

折半查找算法先取线性表的中间元素与查找对象进行比较，如果正好是要查找对象，则查找成功；如果该元素比查找对象大，则要查找的对象只可能在线性表的前半部分，因为后半部分的元素比查找对象更大，可以将后半部分从查找范围中舍去，使查找范围缩小一半，下一步在剩下的一半中继续取其中间元素进行比较和判断，又可以舍去这一部分的一半，在另一半重复上述操作。如此进行下去，直至找到指定对象（成功）或查找范围消失（失败）。因为这种算法每次将查找范围折半，取其中间元素进行比较判断，故称为折半查找算法。

在折半查找的过程中，时刻要变化查找范围，为此需要三个指针变量来配合操作，它们分别指向查找范围的低端（前端）、中点、高端（后端）。开始时整个线性表都在查找范围之中，低端指针指向线性表的首址，高端指针指向线性表的最后一个元素。

北阳电子内部技术资料

4 第一章 凌阳单片机简介

中点指针的值可以由低端指针和高端指针平均求得。当中点元素的值大于查找对象时，说明查找对象只可能在低半部分，新的查找范围和原来的查找范围相比，低端没有变化，高端位置应该调整到比当前中点位置还低一的地方。反之，当中点元素的值小于查找对象时，说明查找对象只可能在高半部分，新的查找范围和原来的查找范围相比，高端没有变化，低端位置应该调整到比当前中点位置还高一的地方，每进行一次查找范围的调整，都应该对新的查找范围进行核实，如果低端指针的值比高端指针的值还要大，则新的查找范围是没有意义的，表示查找范围已经消失，查找以失败告终，以字数据为例，折半查找算法程序流程图如图2所示，程序如下：

图2 有序线性表的折半查找算法流程图

_________________________________________________________________________ //语法:

// C语言:

// int F_Find_Reduce_By_Half(unsigned int LowAddr,unsigned int

// Number,unsigned int Value);

// 汇编:

// R1=[LowAddr];

// R2=[Number];

// R3=[Value];

// PUSH R1,R3 TO [SP];

// CALL F_Find_Reduce_By_Half;

- 4 -

第一章 凌阳单片机简介5 // [Find_Out]=R1

// POP R1，R3 FROM [SP]

//

//参数说明：LowAddr：线性表首地址

// Number：查找数据缓冲区的大小，即数据元素的个数

// Value：要查找的数据

//返回值: R1---查找到的对象

//破坏的寄存器:R1,R2,R3,R4

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// .IRAM

.PUBLIC G_Find_Flag;

.VAR G_Find_Flag=0; //查找结果标志单元，查找成功为1，反之为零

.VAR I_HighAddr=0; //高地址指针

.CODE

.PUBLIC _F_Find_Reduce_By_Half

.PUBLIC F_Find_Reduce_By_Half

_F_Find_Reduce_By_Half: .PROC

F_Find_Reduce_By_Half:

PUSH BP,BP TO [SP]

BP=SP; //BP指向堆栈

BP+=4; //BP指向第一个参数位置

R1=[BP++]; //取线性表首址

R2=[BP++]; //取数据元素个数

JZ L_EXIT_FIND; //数据元素个数为零,退出查找

R3=[BP]; //取要查找的数据

R4=R1; //线性表首址暂存R4

R4+=R2; //线性表首址加数据元素个数

R4-=1; //线形表最后一个元素的地址

[I_HighAddr]=R4; //保存高地址

L_Find_DATA:

R4-=R1; //高地址减去低地址

JNB L_Find_DATA_00;//高地址小于低地址结束查找

L_EXIT_FIND:

R1=0 //返回值单元清零

[G_Find_Flag]=R1; //设置查找不成功标志

PUSH BP,BP TO [SP];

RETF;

L_Find_DATA_00:

R4=[I_HighAddr]; //取高地址

R4+=R1; //高地址加低地址

R4=R4 LSR 1; //地址和除二取中间地址

北阳电子内部技术资料

6 第一章 凌阳单片机简介

R2=[R4]; //取中间数

CMP R2,R3; //是要查找的数吗？

JZ L_FIND_OUT; //是要查找的数

JNB L_Find_DATA_10;//大于要查找的数

R4+=1; //小于要查找的数，高地址加一

R1=R4; //高地址送给R1作为当前低地址，高地址不变

JMP L_Find_DATA;

L_Find_DATA_10:

R4-=1; //高地址减一

[I_HighAddr]=R4; //高地址减一，作为当前高地址，低地址不变JMP L_Find_DATA;

L_FIND_OUT:

R1=R2; //查找结果存于R1作为返回值

R2=1; //R2置一

[G_Find_Flag]=R2; //设置查找成功标志

POP BP,BP FROM [SP];

RETF;

.ENDP;

_________________________________________________________________________

3.3分块查找

分块查找又称索引查找，在生活中我们经常使用这种查找方法。例如，我们要在一本书中查找所需资料，一般是先查它的目录，找到这些资料所在章节的起始页面，然后直接翻到这一页，再从这一页仔细开始阅读，查找所需资料，这显然比从头开始查找要快捷的多。我们之所以能在厚厚的书籍中迅速找到所要的内容，是因为事先把所有的内容按照一个特定的规律分成若干块（章），每一块中又分成若干小块（节），安排好了它们的位置（页面），然后给出一张目录表，有了这张目录表，才使查找变得迅速。这张目录表又称为索引表，所以这种查找算法又称为索引查找算法。我们以一个大批数据的集合为例，把它们分成若干块，每一块内部的元素可以是有序的（块内有序），也可以是无序的（块内无序），但要求后一块中的各个元素都比前一块中的任何元素都大（块间有序）。然后列出一张索引表，索引表的每一项对应一个数据块，故索引表的项数等于数据块的的块数。索引表中的每一项又包含两个内容，一个内容是对应数据块的起始地址，另一个内容是对应数据块中所有数据的最大值。当数据量很大时，可以建立多级索引表。显然，建立索引表需要开销一些存储单元，整个数据的分块和索引表的建立是事先完成的。

分块查找算法分为两步完成，第一步将查找对象依次和索引表中各块的的最大值进行比较，确定有可能包含查找对象的那一块的首址，同时由该块首址和下一块的首址计算出该块的范围；第二步在指定块内进行查找，如果块内有序就可以采用折半查找法，如果块内无序就只好采用顺序查找算法。为了得到最后一块数据块的范围，我们可以在索引表的最后增加一项虚拟块的边界地址，虚拟块的最大值没有意义。下面我们以查找一个字数据对象为例来说明分块查找的过程，数据块内是无序的。程序流程图如图3所示，程序如下：

- 6 -

第一章 凌阳单片机简介7

图3 分块查找算法流程图

_________________________________________________________________________ //语法:

// C语言:

// int F_Find_In_Block(unsigned int Index_Addr,unsigned int

// Number,unsigned int Value);

// 汇编:

// R1=[Index_Addr];

// R2=[Number];

// R3=[Value];

// PUSH R1,R3 TO [SP];

// CALL F_Find_In_Block;

// [Find_Out]=R1

北阳电子内部技术资料

8 第一章 凌阳单片机简介

// POP R1，R3 FROM [SP]

//

//参数说明：LowAddr：线性表首地址

// Number：查找数据缓冲区的大小，即数据元素的个数

// Value：要查找的数据

//返回值: R1---查找到的对象

//破坏的寄存器:R1,R2,R3,R4

//////////////////////////////////////////////////////////////////// .IRAM

.PUBLIC G_Find_Flag;

.VAR G_Find_Flag=0; //查找结果标志单元，查找成功为1，反之为零

.VAR I_Max_Data=0; //每块中最大的数据

.VAR I_Block_Addr=0; //每块的起始地址

.CODE

.PUBLIC _F_Find_In_Block

.PUBLIC F_Find_In_Block

_F_Find_In_Block: .PROC

F_Find_In_Block:

PUSH BP,BP TO [SP];

BP=SP; //BP指向堆栈

BP+=4; //BP指向第一个参数位置

R1=[BP++]; //索引表首址

R2=[R1];

[I_Block_Addr]=R2; //数据块地址

R2=[BP++]; //数据块的个数

JZ L_Exit_Find_00; //数据块的个数为零，退出查找

R3=[BP]; //要查找的数据

L_Find_Block:

R4=[++R1]; //取数据块最大元素的地址

R4=[R4]; //取数据块最大元素

CMP R4,R3; //与查找元素比较

JNB L_Find_Block_Out;//大于查找元素

R2-=1; //小于查找元素，数据块个数减一

CMP R2,0; //每一个数据块都查找过吗？

JB L_Exit_Find_00; //每一个数据块都查找过

PUSH R2,R2 TO [SP]; //R2入栈

R1-=1; //R1减一

R2=[R1]; //取出数据块首址

[I_Block_Addr]=R2; //数据块首址保存

R1+=2; //指向下一个数据块的首址

POP R2,R2 FROM [SP]; //R2出栈

JMP L_Find_Block;

- 8 -

第一章 凌阳单片机简介9

L_Find_Block_Out:

R2=[++R1]; //取下一个数据块的首址

R4=[I_Block_Addr]; //取数据块首址

R2=R2-R4; //计算数据块中元素个数

L_Find_Data_00:

R1=[R4++]; //在数据块中用顺序查找法查找目标元素

R2-=1;

JZ L_Exit_Find_00;

CMP R1,R3;

JNZ L_Find_Data_00;

R2=1; //设置查找成功

[G_Find_Flag]=R2;

JMP L_Exit_Find;

L_Exit_Find_00:

R1=0; //返回单元清零

[G_Find_Flag]=R1; //设置查找不成功标志

L_Exit_Find:

POP BP,BP FROM [SP];

RETF;

.ENDP;

_________________________________________________________________________

3.4 串的匹配

串也是一种线性表。一般情况下，串的一个元素占一个字节（在十六位单片机中占一个字），如字符串；所以称串为有限的字符序列。串类似于数组，串的存储结构有顺序存储和链式存储。顺序存储的串便于访问（如匹配），而链式存储的串便于插入和删除等操作，在单片机中，基本上都是采用顺序存储方式。对于一个串，我们起码要知道它的两条属性，一是它在存储器中的首址，二是它的长度；若长度为零，称为空串。一个串可以包含若干个子串；所谓子串就是指串中任意个连续字符组成的子序列。

设串S=“MICROCOMPUTER”；串T1=“MIC”；T2=“CROCO”；则T1，T2就是串S的子串，我们不妨称S为主串。当然，一个子串中又可以子串，它们自然也是串S的子串。

所谓串的匹配又称为模式匹配，实际上也是一种查找。就是在一个主串S中寻找一个给定的模式串T；若匹配成功，则模式串T就是主串S的子串，且给出串T在串S 中的位置。

例如，设主串=“THE WONDERFUL MACHINE！”，待匹配的模式串有两个，分别是T1=“RFUL”；和T2=“MACHIN”。则，串T1在主串S中的位置序号是10，串T2在主串S 中的位置序号是15。这里的位置序号是相对于主串S的第一个元素，改变搜索起点，这些位置也相对变化。在实际模式匹配算法中，当匹配成功时，一般返回模式串在主串中的起始位置。

有一种简单直观的模式匹配法，简称BF算法（Brute-Force算法），这种算法的基本思路是：把模式串当作一个模板，先和主串前端对齐，然后进行比较，如果完全相

北阳电子内部技术资料

10 第一章 凌阳单片机简介

- 10 -

同则匹配成功。如果有差异则将模板向后移动一个位置，即将模板的前端和主串的第二个元素对齐，继续进行下一轮比较，直到匹配成功或者将模板移动到主串之后而匹配失败。

当主串和模式串一样长时，进行一轮匹配操作便可得到结果（主串中是否包含模式串），如果主串比模式串长度大一，则最多需要进行两轮匹配操作便可得到结果。依次类推，设主串S 的长度为N ，模式串T 的长度为M （不大于N ），则最多只要进行N-M+1轮匹配操作就可以得到结果。在每轮匹配操作的过程中，将模式串的各个元素依次和主串中的元素进行比较，由于模式串的长度为M ，故最多进行M 次比较便可得到结果（本轮匹配操作是成功还是失败）。主串一般比较长，如果是一个固定文件（如词典）通常是固化在EPROM 中，如果是动态文件（如正在输入和编辑中的文件）则存放在片外RAM 中，模式串一般简短，为了操作方便，将其存放在片内RAM 中为宜。我们以一个不超过256字的主串为例，BF 算法的程序流程图如图4所示，程序如下：

__________________________________________________________________________ //语法:

//C 语言: // int F_Find_By_Brute_Force(unsigned int Main_String_Addr,unsigned int

// Main_String_Length,unsigned int Find_String_Addr, // unsigned int Find_String_Length);

//汇编:

// R1=

[Main_String_Addr];

// R2=[Main_String_Length];

// R3=[Find_String_Addr];

// R4=[Find_String_Length]

// PUSH R1,R4 TO [SP];

// CALL F_Find_By_Brute_Force;

// [Find_Out]=R1

// POP R1，R4 FROM [SP]

//参数说明: Main_String_Addr: 主串首地址

// Main_String_Length: 主串长度

// Find_String_Addr: 模式串首地址

// Find_String_Length: 模式串长度

//返回值: R1---查找到的对象

//破坏的寄存器:R1,R2,R3,R4

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// .IRAM

.PUBLIC G_Find_Flag;

.VAR G_Find_Flag=0; //查找结果标志单元，查找成功为1，反之为零 .VAR I_MainStr_Temp_Addr=0; //主串首地址

.VAR I_FindStr_Temp_Addr=0; //模式串地址

.VAR I_FindStr_Temp_Length=0; //模式串长度

.VAR I_MainStrTempAddr=0; //主串地址暂存单元

第一章 凌阳单片机简介11

.VAR I_FindStrTempAddr=0; //模式串地址暂存单元

.CODE

.PUBLIC _F_Find_By_Brute_Force

.PUBLIC F_Find_By_Brute_Force

_F_Find_By_Brute_Force: .PROC

F_Find_By_Brute_Force:

PUSH BP,BP TO [SP];

BP=SP+1; //BP指向堆栈

BP+=3; //BP指向第一个参数位置

R1=[BP++]; //主串首址

[I_MainStr_Temp_Addr]=R1; //主串首址暂存

[I_MainStrTempAddr]=R1;

R2=[BP++]; //主串长度

R3=[BP++]; //模式串首址

[I_FindStr_Temp_Addr]=R3; //模式串首址暂存

[I_FindStrTempAddr]=R3;

R4=[BP++]; //模式串长度

[I_FindStrTempAddr]=R4;

R2-=R4; //主串长度减去模式串长度

JB L_Exit_Find_00; //模式串长度大于主串长度，退出匹配操作R2+=1; //模式串长度小于主串长度，得到最大匹配操

//作遍数

L_BF_10:

R1=[R1]; //取主串的一个元素

R3=[R3]; //取模式串一个元素

CMP R1,R3; //相等吗？

JNZ L_BF_20; //不相等

R1=[I_MainStr_Temp_Addr]; //相等，主串指针加一指向下一个元素

R1+=1;

[I_MainStr_Temp_Addr]=R1;

R3=[I_FindStr_Temp_Addr]; //模式串指针加一指向下一个元素R3+=1;

[I_FindStr_Temp_Addr]=R3;

R4-=1; //模式串元素比较完否？

JNZ L_BF_10; //未完

R4=1; //比较完成

[G_Find_Flag]=R4; //设置匹配成功标志

R1=[I_MainStr_Temp_Addr]; //当前比较位置

R2=[I_FindStrTempAddr]; //取模式串长度

R1-=R2; //得到模式串匹配位置

POP BP,BP FROM [SP];

RETF;

北阳电子内部技术资料

12 第一章 凌阳单片机简介

L_BF_20:

R1=[I_MainStrTempAddr]; //主串指针加一

R1+=1;

[I_MainStrTempAddr]=R1; //保存当前主串指针位置

[I_MainStr_Temp_Addr]=R1; //初始化比较位置

R3=[I_FindStrTempAddr]; //取出模式串首址

[I_FindStr_Temp_Addr]=R3; //恢复模式串地址

R4=[I_FindStrTempAddr]; //恢复模式串比较次数

R2-=1; //所有元素比较完否？

JNZ L_BF_10; //未完

L_Exit_Find_00:

R1=0; //比较结束，返回单元清零

[G_Find_Flag]=R1; //设置不成功标志

L_Exit_Find:

POP BP,BP FROM [SP];

RETF

.ENDP

__________________________________________________________________________ 在BF算法中，当某一轮匹配失败之后，下一轮主串S的比较起始位置只能比上一轮的起始位置向前增加一个元素的地址，因此，BF算法的运行效率是很低的。我们完全可以充分利用上一轮匹配操作的结果和模式串本身的特点来提高本轮匹配操作的效率。例如，设主串为S=“ABCSERFABCDGKURQAC”，模式串为T=“ABCD”，第一轮匹配操作从主串和模式串的第一个元素开始比较，主串的前三个元素和模式串相同，比较到第四个元素时匹配失败（主串的第四个元素不是“D”）。按BF算法，下一轮应该将主串的“BCSE”和模式串进行匹配操作。事实上模式串第一个元素的内容是“A”没有必要从主串的第二个元素和第三个元素开始进行匹配操作，可以直接从刚才比较失败的第四个元素开始进行匹配操作（主串第四个元素虽然不是“D”，但有可能是“A”）。这样处理后，主串的指针在整个模式匹配过程中就不用后退了，从而大大提高了效率。在很多情况下模式串的第一个元素和其它元素是不同的可以采用这种改进的模式匹配算法来提高效率。如果不满足这个条件，，例如，模式串为“ABABC”，则算法要复杂一些，有一种称为KMP的算法可以处理这种情况，有兴趣的读者可以阅读参考文献[2]中的有关内容。事实上，我们这里的改进算法就是KMP算法的一个特例，只是因为它符合大多数实际情况，没有必要搞得象标准的KMP算法那样复杂。在满足模式串的第一个元素和模式串的其它元素都不相同的条件下，改进算法的程序流程图如图5所示，程序如下：

__________________________________________________________________________ //语法:

// C语言:

// int _F_Find_By_Q_Brute_Force(unsigned int Main_String_Addr,unsigned // int Main_String_Length,unsigned int

// Find_String_Addr, unsigned int

// Find_String_Length);

// 汇编:

- 12 -

第一章 凌阳单片机简介13

// R1=[Main_String_Addr];

// R2=[Main_String_Length];

// R3=[Find_String_Addr];

// R4=[Find_String_Length]

// PUSH R1,R4 TO [SP];

// CALL _F_Find_By_Q_Brute_Force;

// [Find_Out]=R1

// POP R1，R4 FROM [SP]

//参数说明: Main_String_Addr: 主串首地址

// Main_String_Length: 主串长度

// Find_String_Addr: 模式串首地址

// Find_String_Length: 模式串长度

//返回值: R1---查找到的对象

//破坏的寄存器:R1,R2,R3,R4

////////////////////////////////////////////////////////////////////////// .IRAM

.PUBLIC G_Find_Flag;

.VAR G_Find_Flag=0; //查找结果标志单元，查找成功为1，反之为零

.VAR I_MainStr_Temp_Addr=0; //主串首地址

.VAR I_FindStr_Temp_Addr=0; //模式串地址

.VAR I_FindStr_Temp_Length=0; //模式串长度

.VAR I_MainStrTempAddr=0; //主串地址暂存单元

.VAR I_FindStrTempAddr=0; //模式串地址暂存单元

.CODE

.PUBLIC _F_Find_By_Q_Brute_Force

.PUBLIC F_Find_By_Q_Brute_Force

_F_Find_By_Q_Brute_Force: .PROC

F_Find_By_Q_Brute_Force:

PUSH BP,BP TO [SP];

BP=SP+1; //BP指向堆栈

BP+=3; //BP指向第一个参数位置

R1=[BP++]; //主串首址

[I_MainStr_Temp_Addr]=R1; //主串首址暂存

[I_MainStrTempAddr]=R1;

R2=[BP++]; //主串长度

R3=[BP++]; //模式串首址

[I_FindStr_Temp_Addr]=R3; //模式串首址暂存

[I_FindStrTempAddr]=R3;

R4=[BP++]; //模式串长度

[I_FindStrTempAddr]=R4;

CMP R2,R4 //主串长度减去模式串长度

JB L_Exit_Find_00; //模式串长度大于主串长度，退出匹配操作

L_Q_BF_10:

R1=[R1]; //取主串的一个元素

北阳电子内部技术资料

14 第一章 凌阳单片机简介

R3=[R3]; //取模式串一个元素

CMP R1,R3; //相等吗？

JNZ L_Q_BF_20; //不相等

R1=[I_MainStr_Temp_Addr]; //相等，主串指针加一指向下一个元素

R1+=1;

[I_MainStr_Temp_Addr]=R1;

R3=[I_FindStr_Temp_Addr]; //模式串指针加一指向下一个元素

R3+=1;

[I_FindStr_Temp_Addr]=R3;

R2-=1; //主串尚未参与比较的元素个数减一

R4-=1; //模式串元素比较完否？

JNZ L_Q_BF_10; //未完

R1=1; //比较完成

[G_Find_Flag]=R1; //设置匹配成功标志

R1=[I_MainStr_Temp_Addr]; //当前比较位置

R2=[I_FindStrTempAddr]; //取模式串长度

R1-=R2; //得到模式串匹配位置

POP BP,BP FROM [SP];

RETF;

L_Q_BF_20:

R3=[I_FindStr_Temp_Addr]; //取当前比较位置

CMP R3,[I_FindStrTempAddr]; //是模式串的第一个元素吗？

JNZ L_Q_BF_30; //不是

R1=[I_MainStrTempAddr] //是第一个元素

R1+=1; //主串位置后移一位

[I_MainStrTempAddr]=R1;

[I_MainStr_Temp_Addr]=R1;

R2-=1; //主串未参与比较元素个数减一

R4=[I_FindStrTempAddr]; //设置模式串比较次数

L_Q_BF_30:

R3=[I_FindStrTempAddr];

CMP R2,R3; //未参与比较元素个数是否小于模式串长度 JB L_Exit_Find_00 //小于，退出匹配操作

R3=[I_FindStrTempAddr]; //大于等于恢复模式串首址

[I_FindStr_Temp_Addr]=R3;

JMP L_Q_BF_10; //继续比较

L_Exit_Find_00:

POP R2,R2 FROM [SP]

R1=0; //比较结束，返回单元清零

[G_Find_Flag]=R1; //设置不成功标志

L_Exit_Find:

POP BP,BP FROM [SP];

RETF

.ENDP

- 14 -

第一章 凌阳单片机简介15 __________________________________________________________________________

图4 模式匹配的BF算法

北阳电子内部技术资料

16 第一章 凌阳单片机简介

图5 改进的模式匹配BF算法

3.5 查找算法应用实例

- 16 -

第一章 凌阳单片机简介 北阳电子内部技术资料

17

有一台野外数据采集仪，将采集的数据保存在带掉点保护的片外RAM 中，它可以在野外工作一段较长的时间，

记录大量的数据，返回基地后

再通过串行通讯将数据传送

给通用计算机。在该仪器中，每一次采集的数据作为一个数据包，各个数据包顺序存放

在片外RAM 。每个数据包由起

始标志、数据块、结束标志组成。起始由六个字节组成，前三个字节的内容均为“FF”，后三个字节分别为BCD 码的月份、日期和批次，例如3月25

日第7批数据的起始标志为

“FF FF FF 03

07”。结束标志也由6个字节组成，前三个字节的内容均为

“EE”，后三个字节也是BCD 码的月份、日期和批次。数据块由若干数据元素组成，每个数据元素均为三个字节，第一个字节为类型码（说明数据类型），后两个字节为数值。为

了保证起始标志和结束标志

的专一性，在数据块中就不能出现连续的三个“FF”或三个

“EE”。为此，数据元素中的

数值部分用不包含“FF ”和“EE”的BCD 码表示。片外RAM

的容量为8K ，地址范围为

2000H-3FFFH ，其中2000H-203FH 为系统参数存储

区，用来存储采集数据的地址

范围为2040H-3FFFH。由于每个数据包的大小是不定的为

了节省存储空间，将各个数据

包顺序存放，并将2040H-3FFFH 的存储空间看成

环行空间，即3FFFH 单元的下

一个单元就是2040H 单元（绕过系统参数区）。在这些约定

下，为了读取某个数据包的数据，必须先找到这个数据包的起始标志，起始标志后面就是所需数据区。查找起始标志的算法显然是属于模式匹配法，模式串的前三个字节为固定的“FF”，后三个字节为变量，它的内容由人们指定。为了提高效率，不能采用

图6 查找起始标志的算法

18 第一章 凌阳单片机简介

BF算法；另一方面，由于前三个字节相同，也不能采用前面介绍的改进算法。针对这里的具体情况，我们将查找过程分为两步，先查找连续的“FF”字节片段，如果该片段的长度达到或超过三个字节再判断其后面的三个字节中的内容是否为指定的月份、日期和批次。由于片外RAM空间为环行结构，起始标志有可能正好处于折回位置例如在3FFEH和3FFFH中装下两个字节的“FF”，再在2040H-2043H装下剩下的四个字节“FF 03 25 07”。为了不遗漏这种情况，查找范围的长度必须略大于整个数据区，这里定为2000H（总数）-40H（参数区）+8=1FC8H。综上所述，查找起始标志的算法流程图如图6所示，程序如下：

__________________________________________________________________________ //数据格式:字

//语法:

// C语言:

// int F_Find_By_Flag(unsigned int Month,unsigned int Day,unsigned int // Number,unsigned int Flag,unsigned int Data_Addr, // unsigned int Data_Length);

// 汇编:

// R1=[Month];

// R2=[Day];

// R3=[Number];

// R4=[Flag]

// PUSH R1,R4 TO [SP];

// R1=[Data_Addr];

// R2=[Data_Length]

// PUSH R1,R2 TO [SP];

// CALL F_Find_By_Flag;

// [Find_Out]=R1

// POP R1,R2 FROM [SP]

// POP R1,R4 FROM [SP]

//参数说明:Month: 查找月份

// Day: 查找日期

// Number:查找批号

// Flag: 数据区起始标志

// Data_Addr:数据区首地址

// Data_Length:数据区长度

//返回值: R1---查找到的对象

//破坏的寄存器:R1,R2,R3,R4

////////////////////////////////////////////////////////////////////// .IRAM

.PUBLIC G_Find_Flag;

.VAR G_Find_Flag=0; //查找结果标志单元，查找成功为1，反之为零

.VAR I_Flag_Count=0; //起始标志计数单元

.VAR I_Month=0; //查找月份单元

.VAR I_Day=0; //查找日期单元

.VAR I_Number=0; //查找批号单元

- 18 -

第一章 凌阳单片机简介19

.VAR I_Flag=0; //查找标志单元

.VAR I_End_Addr=0; //数据区结束地址

.VAR I_Data_Addr=0; //数据区首址

.CODE

.PUBLIC _F_Find_By_Flag

.PUBLIC F_Find_By_Flag

_F_Find_By_Flag: .PROC

F_Find_By_Flag:

PUSH BP,BP TO [SP];

BP=SP+1; //BP指向堆栈

BP+=3; //BP指向第一个参数位置

R1=[BP++]; //月份

[I_Month]=R1;

R1=[BP++]; //日期

[I_Day]=R1;

R1=[BP++]; //批号

[I_Number]=R1;

R1=[BP++]; //起始标志

[I_Flag]=R1;

R1=[BP++]; //数据区首址

[I_Data_Addr]=R1;

R2=[BP++]; //缓冲区长度

R1+=R2; //计算结束地址

[I_End_Addr]=R1; //保存结束地址

R1=[I_Data_Addr];

R2=[BP] ; //最大访问长度

JZ L_Exit_Find_00; //访问长度为零，退出查找操作

L_FN_10:

R3=[R1]; //取一个数据

CMP R3,[I_Flag]; //是起始标志位吗?

JNZ L_FN_20; //不是

R3=[I_Flag_Count]; //是,取出计数器中的计数值

R3+=1; //计数值加一

[I_Flag_Count]=R3; //计数值保存于计数器

JMP L_FN_30; //继续查找

L_FN_20:

R3=[I_Flag_Count];

CMP R3,3; //已经有3个或3个以上的起始标志吗?

JB L_FN_30; //没有,继续查找

R3=0; //有,清除计数器

[I_Flag_Count]=R3;

R3=[R1]; //前面已经有3个或3个以上的起始标志,读取当前内容

CMP R3,[I_Month]; //是指定月份吗?

北阳电子内部技术资料

20 第一章 凌阳单片机简介

JNZ L_FN_30; //不是,继续查找

R3=[++R1]; //取下一个数据

CMP R3,[I_Day]; //是指定日期吗?

JNZ L_FN_30; //不是,继续查找

R3=[++R1]; //取下一个数据

CMP R3,[I_Number]; //是指定的批号吗?

JNZ L_FN_30; //不是,继续查找

R1=R1+1; //是,指针指向数据区

R2=1; //设置,查找成功标志

[G_Find_Flag]=R2;

POP BP,BP FROM [SP];

RETF

L_FN_30:

R1+=1; //调整指针指向下一个数据

CMP R1,[I_End_Addr];

JB L_Return_Here

R1=[I_Data_Addr]; //高于查找范围,恢复地址指针

L_Return_Here:

R2-=1; //所有元素都比较完了吗?

JNZ L_FN_10; //未完,继续比较

R1=0; //比较结束，返回单元清零

[G_Find_Flag]=R1; //设置不成功标志

L_Exit_Find_00:

POP BP,BP FROM [SP];

RETF;

.ENDP

______________________________________________________________________________________

- 20 -