亚洲国产91色在线,日韩三级影视,中文字幕国产在线

扑և�数组中唯一重复的数

fly — Thu, 27 Mar 2014 11:40:00 GMT

题目�Q?/p>

数组a[N]�Q?至N-1�q�N-1个数存放在a[N]中，其中某个数重复一�ơ。写一个函敎ͼ�扑և�被重复的数字�?/p>

�Ҏ(gu��)��一�Q�异或法�?/p>

数组a[N]中的N个数异或�l�果�?至N-1异或的结果再做异或，得到的值即为所求�?/p>

��N��复数为A�Q�其余N-2个数异或�l�果为B�?/span>
N个数异或�l�果为A^A^B
1至N-1异或�l�果为A^B
�׃��异或满��交换律和�l�合律，且X^X = 0 0^X = X;
则有
(A^B)^(A^A^B)=A^B^B=A

代码�Q?/p>

#include   
#include   
#include   
#include  
void xor_findDup(int * a,int N)    
{    
    int i;    
    int result=0;    
    for(i=0;i
    {    
        result ^= a[i];    
    }    
      
    for (i=1;i
    {    
        result ^= i;    
    }    
      
    printf("%d\n",result);    
      
}    
 
 
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,2,1,3,4};    
    xor_findDup(a,5);    
    return 0;    
}

�Ҏ(gu��)��二：数学法�?/p>

�Ҏ(gu��)��l�的所有项求和�Q�减�?至N-1的和�Q�即为所求数�?/p>

#include   
#include   
#include   
#include  
void xor_findDup(int * a,int N)    
{    
    int tmp1 = 0;  
      
    int tmp2 = 0;  
      
    for (int i=0; i
          
    {  
          
        tmp1+=(i+1);  
          
        tmp2+=a[i];  
          
    }  
    tmp2+=a[N-1];  
    int result=tmp2-tmp1;     
    printf("%d\n",result);    
      
}    
 
 
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,2,4,3,4};    
    xor_findDup(a,5);    
    return 0;    
}

对于求和�Q�可以直接根据公式定义一个宏�?define sum(x) (x*(x+1)/2)

#include   
#include   
#include   
#include  
#define sum(x)  (x*(x+1)/2)   
void xor_findDup(int * a,int N)    
{    
    int tmp1 = sum((N-1));//注意N-1要加括号     
    int tmp2 = 0;  
      
    for (int i=0; i
    {             
        tmp2+=a[i];   
    }  
    int result=tmp2-tmp1;     
    printf("%d\n",result);        
}    
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,2,4,2,3};    
    xor_findDup(a,5);    
    return 0;    
}

�Ҏ(gu��)��三：标志数组�?/p>

甌��一个长度�ؓn-1且均�?0'�l�成的字�W�串。然后从头遍历a[n]数组�Q�取每个数组元素a[i]的��|��其对应的字�W�串中的相应位置�|?�Q�如果已�l�置�q?的话�Q�那么该数就是重复的数。就是用位图来实现的�?如果考虑�I�间复杂度的话，其空间O�Q�N�Q?/p>

#include   
#include   
#include   
#include  
#define sum(x)  (x*(x+1)/2)   
void xor_findDup(int * arr,int NUM)    
{    
    int *arrayflag = (int *)malloc(NUM*sizeof(int));      
    int i=1;  
      
    while(i
    {  
        arrayflag[i] = false;  
        i++;  
    }     
      
    for( i=0; i
    {         
        if(arrayflag[arr[i]] == false)            
            arrayflag[arr[i]] = true;          // �|�出现标�? 
          
        else      
        {   
            printf("%d\n",arr[i]);  
            return ; //�q�回已经出现的�? 
        }  
          
     }    
}    
 
int main(int argc, char* argv[])    
{    
    int a[] = {1,3,2,4,3};    
    xor_findDup(a,5);    
    return 0;    
}

�Ҏ(gu��)��四：固定偏移量法

a[N]�Q�里面是1至N-1。原数组a[i]最大是N-1�Q�若a[i]=K在某处出现后�Q�将a[K]加一�ơN�Q�做标记�Q�当某处a[i]=K再次成立�Ӟ��查看a[K]卛_��知道K已经出现�q�。该�Ҏ(gu��)��不用另外开辟O(N)的内存空��_��但是在查重之后要��数�l�进行恢复�?/p>

#include   
#include   
#include   
#include  
void xor_findDup(int * arr,int NUM)    
{    
    int temp=0;       
    for(int i=0; i
    {  
          
        if(arr[i]>=NUM)           
            temp=arr[i]-NUM;            // 该值重复了�Q�因为曾�l�加�q�一�ơ了        
        else              
            temp=arr[i];          
                  
        if(arr[temp]
        {         
            arr[temp]+=NUM; //做上标记            
        }  
          
        else              
        {             
            printf("有重�?nbsp;%d\n",temp);              
            return;           
        }         
    }  
              
    printf("无重�?);  
    return ;   
}    
void clear(int *data,int num)//清理数据  
{  
    for(int i=0;i
    {  
        if(data[i]>num)  
            data[i]-=num;  
    }  
 
}  
int main(int argc, char* argv[])    
{    
    int a[] = {2,4,3,4,1};    
    xor_findDup(a,5);    
    clear(a,5);  
    return 0;    
}

�Ҏ(gu��)��五：�W�号标志�?/p>

上个�Ҏ(gu��)��出现后是加N�Q�也可以出现后加个负��P��是�W�号标志法�?/p>

#include   
#include   
#include   
#include   
#include  
 
void xor_findDup(int * arr,int NUM)    
{         
    int temp=0;          
    for(int i=0; i
    {                    
        if(arr[i]<0)     
            temp=0-arr[i];  // 该值重复了�Q�因为曾�l�加�q�一�ơ了     
        else                           
            temp=arr[i];                
        if(arr[temp]>0)             
        {                    
            arr[temp]=0-arr[temp]; //做上标记        
        }                
        else              
        {               
            printf("有重�?nbsp;%d\n",temp);      
            return;               
        }            
    }                
    printf("无重�?);    
    return ;    
 }     
 void clear(int *data,int num)//清理数据  
 {     
     for(int i=0;i
     {        
         if(data[i]<0)           
             data[i]=0-data[i];     
   }     
}    
 int main(int argc, char* argv[])    
 {        
     int a[] = {3,2,1,4,1};       
     xor_findDup(a,5);     
     clear(a,5);      
     return 0;    
 }

以上的方法对数组元素的值的范围是有限制的，如果数组元素的��g��是在1至N-1范围�Ӟ��可以先求出数�l�元素的最大倹{�?/p>

#include
#include
#include
#include
#include
int do_dup_mal(int arr[], int n, int *pre, int *back)
{
int MAX = -1;
int i = 0;
int sameVal = -1;
*pre = *back = -1;
for (int j=0; j
{
if (arr[j] > MAX) MAX = arr[j];//扑և�数组中的最大数
}
char *arrayflag = new char[MAX+1] ;
if (NULL == arrayflag)
return -1;
memset(arrayflag, 0, MAX+1 ); // '\0' == 0
for(i=0; i
{
if(arrayflag[arr[i]] == '\0')
arrayflag[arr[i]] = '\1'; // �|�出现标�?
else
{
sameVal = arr[i]; //�q�回已经出现的�?
*back = i;
break;
}
}
delete[] arrayflag;
if (i < n)
{
for (int j=0; j
{
if (sameVal == arr[j])
{
*pre = j;
return true;
}
}
}
return false;
}
void main(int argc, char *argv[])
{
int prePos = -1, backPos = -1;
int myArry[11];
myArry[0] = 1;
myArry[1] = 3;
myArry[2] = 3;
myArry[3] = 4;
myArry[4] = 5;
myArry[5] = 22;
myArry[6] = 7;
myArry[7] = 13;
myArry[8] = 9;
myArry[9] = 2;
myArry[10] = 12;
if (do_dup_mal(myArry, 11, &prePos, &backPos) )
printf("%d\n",myArry[prePos]);
}

转：http://buptdtt.blog.51cto.com/2369962/749049

fly 2014-03-27 19:40 发表评论

fly — Wed, 10 Apr 2013 16:35:00 GMT

目前�Q�最常见的排序算法大概有七八�U�，其中"快速排�?�Q�Quicksort�Q��用得最�q�泛�Q�速度也较快。它是图灵奖得主C. A. R. Hoare�Q?934--�Q�于1960时提出来的�?/p>

"快速排�?的思想很简单，整个排序�q�程只需要三步：

　　�Q?�Q�在数据集之中，选择一个元素作�?基准"�Q�pivot�Q��?/p>
　　�Q?�Q�所有小�?基准"的元素，都移�?基准"的左边；所有大�?基准"的元素，都移�?基准"的右辏V�?/p>
　　�Q?�Q�对"基准"左边和右边的两个子集�Q�不断重复第一步和�W�二步，直到所有子集只剩下一个元素�ؓ止�?/p>

举例来说�Q�现在有一个数据集{85, 24, 63, 45, 17, 31, 96, 50}�Q�怎么对其排序呢？

�W�一步，选择中间的元�?5作�ؓ"基准"。（基准值可以�Q意选择�Q�但是选择中间的值比较容易理解。）

�W�二步，按照��序�Q�将每个元素�?基准"�q�行比较�Q��Ş成两个子集，一�?��于45"�Q�另一�?大于�{�于45"�?/p>

�W�三步，对两个子集不断重复第一步和�W�二步，直到所有子集只剩下一个元素�ؓ止�?/p>

下面参照�|�上的资料（�q�里�?a target="_blank">�q�里�Q�，用Javascript语言实现上面的算法�?/p>

首先�Q�定义一个quickSort函数�Q�它的参数是一个数�l��?/p>

var quickSort = function(arr) {

};

然后�Q�检查数�l�的元素个数�Q�如果小于等�?�Q�就�q�回�?/p>

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

};

接着�Q�选择"基准"�Q�pivot�Q�，�q�将其与原数�l�分��，再定义两个空数组�Q�用来存放一左一右的两个子集�?/p>

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2) ;

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

};

然后�Q�开始遍历数�l�，��于"基准"的元素放入左边的子集�Q�大于基准的元素攑օ�双��的子集�?/p>

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2) ;

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

　　for (var i = 0; i < arr.length; i++){

　　　　if (arr[i] < pivot) {

　　　　　　left.push(arr[i]);

　　　　} else {

　　　　　　right.push(arr[i]);

　　　　}

　　}

};

最后，使用递归不断重复�q�个�q�程�Q�就可以得到排序后的数组�?/p>

var quickSort = function(arr) {

　　if (arr.length <= 1) { return arr; }

　　var pivotIndex = Math.floor(arr.length / 2);

　　var pivot = arr.splice(pivotIndex, 1)[0];

　　var left = [];

　　var right = [];

　　for (var i = 0; i < arr.length; i++){

　　　　if (arr[i] < pivot) {

　　　　　　left.push(arr[i]);

　　　　} else {

　　　　　　right.push(arr[i]);

　　　　}

　　}

　　return quickSort(left).concat([pivot], quickSort(right));

};

使用的时候，直接调用quickSort()��p��了�?

�Q�完�Q?br />

fly 2013-04-11 00:35 发表评论

java实现快速排�?�?

fly — Wed, 10 Apr 2013 16:30:00 GMT

说来感到惭愧�Q�昨天看别�h的博客上面一一讲了一些算法，其实�q�些��法在大学都学过�Q�不�q�几乎全部忘��C��。虽然现在做java上层开发基本上用不到算法，但是�q�是感觉��法是一�U�思想�Q�是一�U�灵��，所以又不仅��d��了严蔚敏老师的数据结构，一个一个把以前忘记的算法实��C��遍�?

快速排序的基本思想�Q?/p>

通过一��排序将待排序记录分割成独立的两部分�Q�其中一部分记录的关键字均比另一部分关键字小�Q�则分别对这两部分��l�进行排序，直到整个序列有序�?/p>

先看一下这�q�图�Q?/p>

把整个序列看做一个数�l�，把第零个位置看做中��u�Q�和最后一个比�Q�如果比它小交换�Q�比它大不做��M��处理�Q�交换了以后再和��的那端比，比它?y��u)��不交换�Q�比他大交换。这样��@环往复，一��排序完成，左边��是比中轴小的，双��是比中轴大的，然后再用分治法，分别对这两个独立的数�l�进行排序�?/p>

[html] view plain copy print ?

public int getMiddle(Integer[] list, int low, int high) {
int tmp = list[low]; //数组的第一个作��Z��?nbsp;
while (low < high) {
while (low < high && list[high] > tmp) {
high--;
}
list[low] = list[high]; //比中轴小的记录移��C��?nbsp;
while (low < high && list[low] < tmp) {
low++;
}
list[high] = list[low]; //比中轴大的记录移到高�?nbsp;
}
list[low] = tmp; //中��u记录到尾
return low; //�q�回中��u的位�|?nbsp;
}

public int getMiddle(Integer[] list, int low, int high) {
		int tmp = list[low];    //数组的第一个作��Z���?
		while (low < high) {
			while (low < high && list[high] > tmp) {
				high--;
			}
			list[low] = list[high];   //比中轴小的记录移��C���?
			while (low < high && list[low] < tmp) {
				low++;
			}
			list[high] = list[low];   //比中轴大的记录移到高�?
		}
		list[low] = tmp;              //中��u记录到尾
		return low;                   //�q�回中��u的位�|?
	}

递归形式的分��L��序算法：

[html] view plain copy print ?

public void _quickSort(Integer[] list, int low, int high) {
if (low < high) {
int middle = getMiddle(list, low, high); //��list数组�q�行一分�ؓ�?nbsp;
_quickSort(list, low, middle - 1); //对低字表�q�行递归排序
_quickSort(list, middle + 1, high); //寚w��字表�q�行递归排序
}
}

public void _quickSort(Integer[] list, int low, int high) {
		if (low < high) {
			int middle = getMiddle(list, low, high);  //���list数组�q�行一分�ؓ�?
			_quickSort(list, low, middle - 1);        //对低字表�q�行递归排序
			_quickSort(list, middle + 1, high);       //寚w��字表�q�行递归排序
		}
	}

[html] view plain copy print ?

public void quick(Integer[] str) {
if (str.length > 0) { //查看数组是否为空
_quickSort(str, 0, str.length - 1);
}
}

public void quick(Integer[] str) {
		if (str.length > 0) {    //查看数组是否为空
			_quickSort(str, 0, str.length - 1);
		}
	}

�~�写��试�Ҏ(gu��)��Q?

[html] view plain copy print ?

public class TestMain {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Integer[] list={34,3,53,2,23,7,14,10};
QuicSort qs=new QuicSort();
qs.quick(list);
for(int i=0;i<list.length;i++){
System.out.print(list[i]+" ");
}
System.out.println();
}
}

public class TestMain {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         Integer[] list={34,3,53,2,23,7,14,10};
         QuicSort qs=new QuicSort();
         qs.quick(list);
         for(int i=0;i     看一下打印结果吧�Q?
 
     2 3 7 10 14 23 34 53 
    

     �q�样���排序好了，快速排序是对冒泡排序的一�U�改�q�，�q�_��旉���复杂度是O(nlogn)�?br />
 

fly 2013-04-11 00:30 发表评论

fly — Sat, 28 Apr 2012 16:06:00 GMT

我想说一�?#8220;我日�Q�我讨厌KMP�Q?#8221;�?br />KMP虽然�l�典�Q�但是理解�v来极其复杂，好不�Ҏ(gu��)��理解好了�Q�便��L(f��ng)��来巨�ȝ��Q?br />老子��是今天图书馆在写了几个��时才勉强写了一个有bug的、效率不高的KMP�Q�特别是计算next数组的部分�?br />
其实�Q�比KMP��法速度快的��法大把大把�Q�而且理解��h��更简单，��Z��非要抓住KMP呢？�W�试出现字符串模式匹配时直接上sunday��法�Q�既��单又高效�Q�何乐而不为？
说实话，惛_��sunday��法的那个�h�Q�绝�Ҏ(gu��)��发散思维�Q�绝对牛。当我在被KMP折磨的够呛的时候，我就琢磨�Q�有没有别的好算法呢�Q�？琢磨了半天也没想��Z��所以然来。笨啊，脑子不够发散�?br />
下面贴上一位兄弟写的算法�ȝ��Q�很��单（��KMP部分��׃��用看了，看了费脑子）�?br />参见�Q?a >http://hi.baidu.com/willamette/blog/item/02bd0b5599c8b4c0b645ae06.html

��着做Presentation的功夫，��Z��做一个�ȝ��

字符串匹配：

---willamette

在匹配串中寻找模式串是否出现�Q�注意和最长公共子序列相区�?span style="font-family: Times New Roman">(LCS: Longest Common Substring)

-�Q?/strong>Brute Force(BF或蛮力搜�?��法�Q?/strong>

�q�是世界上最��单的��法了�?br />首先��匹配串和模式串左对齐，然后从左向右一个一个进行比较，如果不成功则模式串向右移动一个单位�?/p>
速度最慢�?/p>
那么�Q�怎么改进呢？

我们注意�?span style="font-family: Times New Roman">Brute Force��法是每�ơ移动一个单位，一个一个单位移动显然太慢，是不是可以找��C��些办法，让每�ơ能够让模式串多�U�d��一些位�|�呢�Q?/p>
当然是可以的�?/p>
我们也注意到�Q?span style="font-family: Times New Roman">Brute Force是很�?span style="font-family: Times New Roman">intelligent的，每次匚w��不成功的时候，前面匚w��成功的信息都被当作废物丢弃了�Q�当�Ӟ��如现在的变废�ؓ宝一��P��我们也同样可以将前面匚w��成功的信息利用�v来，极大地减��计��机的处理时��_��节省成本�?span style="font-family: Times New Roman">^_^

注意�Q�蛮力搜索算法虽焉��度慢，但其很通用�Q�文章最后会有一些更多的关于蛮力搜烦的信息�?/span>

-: KMP��法

首先介绍的就�?span style="font-family: Times New Roman">KMP��法�?/p>
原始论文�Q?span style="font-family: Times New Roman">Knuth D.E., Morris J.H., and Pratt V.R., Fast pattern matching in strings, SIAM Journal on Computing, 6(2), 323-350, 1977.

�q�个��法实在是太有名了，大学上的��法评��除了最�W�的Brute Force��法�Q�然后就介绍�?span style="font-family: Times New Roman">KMP��法。也难怪，呵呵。谁�?span style="font-family: Times New Roman">Knuth D.E.�q�么world famous呢，不仅拿了囄��奖，而且�q�写��Z��计算机界�?span style="font-family: Times New Roman">Bible (业内人士一般简�U?span style="font-family: Times New Roman">TAOCP).�E�稍提一下，有个�?span style="font-family: Times New Roman">H.A.Simon的家伙，不仅拿了Turing Award�Q�顺手拿了个Nobel Economics Award�Q�做�?span style="font-family: Times New Roman">AI的爸爸，�q�是Chicago Univ�?span style="font-family: Times New Roman">Politics PhD�Q�可谓全才�?/p>
KMP的具体描�q�略去，教科书一大把�?/span>

-�Q�Horspool��法

Horspool��法�?/p>
当然�Q�有市场��有竞争�Q�字�W�串匚w��q�么大一个市场，不可能让BF�?span style="font-family: Times New Roman">KMP全部占了�Q�于是又出现了几个强劲的�Ҏ(gu��)��?/p>
�W�一个登场的�?/p>
论文�Q?span style="font-family: Times New Roman">Horspool R.N., 1980, Practical fast searching in strings, Software - Practice & Experience, 10(6):501-506

Horspool��法的思想很简单的。不�q�有个创��C��处就是模式串是从叛_��左进行比较的。很好很强大�Q��ؓ后来的算法媄响很大�?/p>
匚w��Ԍ��abcbcsdxzcxx

模式�Ԍ��cbcac

�q�个时候我们从叛_��左进行对暗号�Q?span style="font-family: Times New Roman">c-c�Q�恩对上了，�W�二�?span style="font-family: Times New Roman">b-a�Q�不对啊�Q�我们应该怎么办？��N��p��么放弃么。于是，模式串从不匹配的那个字符开始从叛_��左寻扑֌�配串中不匚w��的字�W?span style="font-family: Times New Roman">b的位�|�，�l�果发现居然有，赶快对上赶快对上�Q�别耽误了�?/p>
匚w��Ԍ��abcbcsdxzcxx

模式�Ԍ�� cbcac

然后�l�箋从最双��的字�W�从叛_��左进行比较。这时候，我们发现了，d-c不匹配啊�Q�而且模式�I�K��面没有噢�Q�没办法�Q�只好移动一个模式串长度的单位了�?/p>
匚w��Ԍ��abcbcsdxzcxx

模式�Ԍ��      cbcac

-�Q�Boyer-Moore��法

对于BM��法�Q�下面推荐一个讲解非�怼��U�的文章，可谓图文�q�茂啊，而且�q�是个MM写的�?/p>
Boyer-Moore �l�典单模式匹配算�?br />http://blog.csdn.net/iJuliet/archive/2009/05/19/4200771.aspx

-�Q�Sunday��法

最后一个是Sunday��法�Q�实际上�?span style="font-family: Times New Roman">Boyer-Moore�q�快�Q�呵��c��长江后��推前浪�?/p>
原始论文�Q?span style="font-family: Times New Roman">Daniel M. Sunday, A very fast substring search algorithm, Communications of the ACM, v.33 n.8, p.132-142, Aug. 1990

看原始论文的题目�Q?span style="font-family: Times New Roman">D.M. Sunday貌似是故意想气气Boyer-Moore两位大牛似的。呵��c��不�q�实际上的确Sunday��法的确�?span style="font-family: Times New Roman">BM��法要快�Q�而且更简单�?/p>
Sunday的算法思想�?span style="font-family: Times New Roman">Horspool有些�怼��Q�但是。当出现不匹配的时候，却不是去扑֌�配串中不匚w��的字�W�在模式串的位置�Q�而是直接找最双��寚w��的右一位的那个字符在模式串的位�|��?/p>
比如�Q?/p>
匚w��Ԍ��abcbczdxzc

模式�Ԍ��zbcac

恩，�q�里我们看到b-a没有对上�Q�我们就看匹配串中的z在模式串的位�|�，然后�Q�嘿�ѝ�?/p>
匚w��Ԍ��abcbczdxzc

模式�Ԍ��     zbcac

如果模式串中的没有那个字�W�怎么办呢�Q�很��单，跌��d��?/p>
匚w��Ԍ��abcbcedxzcs

模式�Ԍ��zbcac

e不在模式串中出现

那么我们��?/p>
匚w��Ԍ��abcbcedxzcs

模式�Ԍ��      zbcac

(2009/10/20补充)
RK��法

某一天在图书馆的一本算法分析设计书上翻到的。思�\很新颖！和大家分享下�?br />在串匚w��的简单算法中�Q�把文本每m个字�W�构成的字符�D�作��Z��个字�D�，和模式进行匹配检查。如果能对一个长度�ؓm的字�W?/p>
串赋以一个Hash函数。那么显然只有那些与模式��h��相同hash函数值的文本中的字符串才有可能与模式匚w��Q�这是必要条�?/p>
�Q�而没有必要去考虑文本中所有长度�ؓm的字�D�，因而大大提高了串匹配的速度。因此RK��法的思想和KMP�Q�BM�Q�Sunday�{��?/p>
路��E然不同！
�Q�事实上�Q�之前的串匹配方法，是将模式串的一个一个字�W�作为小的特征去分别�q�行匚w��Q�而RK��法则是��串整体作�ؓ一�?/p>
特征�Q�难��难在单个字�W�的特征很容易想得到�Q�整体作��Z��个特征就没那么容易想得到了）
如果把整体作��Z��个特征，那么如何快速的求出�q�个整体特征的特征��|��Q?br />模式串的特征��g��需求一�ơ即可。对于文本中的�Q意m个字�W�构成的字串如何快速的求特征就是个隄��了�?br />抛砖引玉�Q�这里给��Z��个简单的特征计算�?��字�W�串的每一个字�W�看做一个数�Q�那么这个字�W�串的就是一个数字数�l�，�?/p>
�q�积分向量可以快速�Q意一个长度子字符串的向量和。可以把字符串的对应的字�W�数�l�的元素和看做这个字�W�串整体特征�?/p>
�q�个特征是可以再O�Q?�Q�的旉��内求出的。其实原始的RK��法里面是把字符串看做一�?6�q�制数在计算特征的。这里就不啰

嗦了�Q�有兴趣的可以深入查�?/p>
aabseesds 模式�?ees
      ees

发现 see向量�?== ees的向量和
然后��对see和ees做逐个字符的比较。发��C��匚w��l�箋往下走
aabseesds 模式�?ees
        ees
发现 ees向量�?== ees的向量和
然后��对ees和ees做逐个字符的比较。发现匹配OK�?br />
另外�q�有字符串匹配自动机后缀树算法（分在�U�和非在�U�两�U�）�{?见如下文章。不能说那个比那个更好，各个��法都有自己的优势及最�?j��ng)_��用场合。参考：
http://blog.csdn.net/yifan403/archive/2009/06/16/4272793.aspx

另外�Q�关于多模式字符串匹�?有AC��法�Q�字�W�串匚w��自动机思想�Q?WM��法�Q�BM在多模式的推�q�应用）
参考：
http://blog.csdn.net/ijuliet/category/498465.aspx 该女子的blog有很多好文章�?br />
===============================================================================
一个sunday��法的实�?br />http://hi.baidu.com/azuryy/blog/item/10d3d3460b97af0e6b63e5cd.html

头文件定义：
/* Sunday.h */
class Sunday
{
public:
   Sunday();
   ~Sunday();

public:
    int find(const char* pattern, const char* text);

private:
    void preCompute(const char* pattern);

private:
    //Let's assume all characters are all ASCII
    static const int ASSIZE = 128;
    int _td[ASSIZE] ;
    int _patLength;
    int _textLength;
};

源文�?br />/* Sunday.cpp */

Sunday::Sunday()
{
}

Sunday::~Sunday()
{
}

void Sunday::preCompute(const char* pattern)
{
    for(int i = 0; i < ASSIZE; i++ )
        _td[i] = _patLength + 1;

    const char* p;
    for ( p = pattern; *p; p++)
        _td[*p] = _patLength - (p - pattern);
}

int Sunday::find(const char* pattern, const char* text)
{
    _patLength = strlen( pattern );
    _textLength = strlen( text );

    if ( _patLength <= 0 || _textLength <= 0)
        return -1;

    preCompute( pattern );

    const char *t, *p, *tx = text;

    while (tx + _patLength <= text + _textLength)
    {
        for (p = pattern, t = tx; *p; ++p, ++t)
        {
            if (*p != *t)
                break;
        }
        if (*p == 0)
            return tx-text;
        tx += _td[tx[_patLength]];
    }
    return -1;
}

��单测试下�Q?br />int main()

{
    char* text = "blog.csdn,blog.net";
    char* pattern = "csdn,blog"    ;
    Sunday sunday;

    printf("The First Occurence at: %d/n",sunday.find(pattern,text));

    return 1;
}

////////////////////////////////////////////
strstr的实现�?br />需要说明的是strstr是c语言提供的��用Brute Force实现的字�W�串匚w��Q�简单、通用是其最大的优点。时间复杂度是O(mn)
// 下面是Microsoft的实�?br />//�l�典��法
//比KMP��法��?没有KMP��法高效
char * __cdecl strstr (
        const char * str1,
        const char * str2
        )
{
        char *cp = (char *) str1;
        char *s1, *s2;
        if ( !*str2 )
            return((char *)str1);
        while (*cp)
        {
                s1 = cp;
                s2 = (char *) str2;
                while ( *s1 && *s2 && !(*s1-*s2) )
                        s1++, s2++;
                if (!*s2)
                        return(cp);
                cp++;
        }
        return(NULL);
}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/whoismickey/archive/2009/02/08/3869367.aspx

strstr

glibc里的strstr函数用的是brute-force(naive)��法�Q�它与其它算法的区别是strstr不对pattern(needle)�q�行预处理，所以用��h��很方�ѝ��理论复杂度O

(mn), 实际上，�q�_��复杂度�ؓO(n), 大部分情况下高度优化的算法性能要优于基于自动机的匹配算法，关于串匹配算法可参�?a >http://www-igm.univ-mlv.fr/~lecroq/string/�?nbsp;glibc中��用了�Q?�Q�Stephen R. van den Berg的实玎ͼ�在他的基��上，�Q?�Q?span style="font-family: 'Courier New'">Tor Myklebust http://sources.redhat.com/ml/libc-alpha/2006-07/msg00028.html�l�出了更复杂的实玎ͼ�当然也更高效�?/div>
BF有一个重要性质是事先不用知道串的长度，而基于蟩跃的��法是需要用字符串长度来判断�l�束位置的。如何快速的��定字符串结束位�|�，可参�?a >http://www.cppblog.com/ant/archive/2007/10/12/32886.html�Q�写的很仔细�?/div>
��两�U�思想�l�合��h��Q�可以做出更快的strstr�Q?�Q�。约定（1�Q?为strstrBerg; (2) 为strstrBergo�Q�（3�Q��ؓlstrstr�Q�（4�Q��ؓglibc中的strstr�Q�简单测试了一下：

从长度�ؓ2k的文本中查找长度�?�?�?的模式串�Q�结果如�?/div>
        1               2              9

�Q?�Q?.000006 0.000006 0.000012

�Q?�Q?.000007 0.000004 0.000008

�Q?�Q?.000002 0.000002 0.000005

�Q?�Q?.000005 0.000005 0.000011
下蝲strstr和测试程�?/a>�Q?
下蝲后执�?:
            unzip testStrstr.zip
            cd testStrstr
            make test

��Z��sse2的strstr函数是用sse2指��o集对strstr的优�?/div>

fly 2012-04-29 00:06 发表评论

Boyer-Moore �l�典单模式匹配算法（转）

fly — Sat, 28 Apr 2012 14:59:00 GMT
摘要: �l�典单模式匹配算法：KMP、BM�Q�经典多模式匚w��法�Q�AC、Wu-Manber。貌似实用中�Q�KMP跟C库strstr()效率相当�Q�而BM能快�?x-5x。于是小女不才花了小天的功夫来研�I�这个BM��法。BM如何快速匹配模式？它怎么跌��圎ͼ�我今儿一定要把大家伙儿讲明白了，讲不明白�(zh��n)��{跟帖�Q�我买单�Q�包教包会�?模式�Q�记为pat�Q�用j作�ؓ索引; 文本�Q�记为string�Q�或text�Q�，用i作�ؓ索引�?&... 阅读全文

fly 2012-04-28 22:59 发表评论