2018.1.25 关于KMP算法的一些自己的理解。

今天着重看了KMP算法的一些东西。

该算法的功能是从一个字符串中判断另一个字符串的存在，即研究的问题是从一个源串中找到标志串的位置。

有了昨天的部分了解，今天终于彻底的了解了这个算法。

我认为这个算法的核心在于next数组的构造和使用。

我认为算法的核心思想是：匹配的过程中，对于遇到的失配情况，不论源串的匹配位置在哪，只要标志串的相同位置失配，移动的位移量是相同的。而next数组就储存了对应的位移量。

next数组在这个算法中的作用是：把字符串匹配过程中遇到的不同情况情况分类，分类标准是标志串失配的位置，在标志串不同的地方遇到的不匹配的情况的是有不同的移动方法。

不同的标志串都有自己的next数组，我们在判断之前要做的就是把next数组求出来。

next数组帮助我们减少重复的比较，可以跳过很多不必要的比较。

例如  ABCDABD

当匹配到第二个A的时候如果失配，可以直接从和第二个A匹配的源串位置开始匹配。

next可以递推求出，语言叙述太过复杂。看懂之后自己尝试着写了一下代码如下：

int KMP(const char *s, const char *p)//KMP算法
{
	int pLen = strlen(p);
	int sLen = strlen(s);
    int *next=new int[pLen];
	//求next数组
	next[0] = -1;  
    int k = -1;  
    int j = 0;  
    while (j < pLen - 1)
    {    
        if (k == -1 || p[j] == p[k])  
        {  
            ++j;  
            ++k;  
            if (p[j] != p[k])  
                next[j] = k;
            else   
                next[j] = next[k];  
        }  
        else 
        {
            k = next[k];
        }
	}
	//next数组计算完毕，开始查找字符串
	int i=0;
	j=0;
	while (i < sLen && j < pLen)  
    {      
        if (j == -1 || s[i] == p[j])  
        {  
            i++;  
            j++;  
        }  
        else  
        {        
            j = next[j];  
        }  
    }  
    if (j == pLen)  
        return i - j;  
    else  
        return -1;  
}

又做了一道题：

 查找数组中某一个数第一次出现的位置，时间复杂度在O（log n）；

 想了想可以用二分查找，但需要改一下，因为需要的是第一次出现的位置。

不怎么难

代码如下：

int binarySearch(int[] nums, int target) {  
        //write your code here  
        if(nums == null || nums.length == 0) return -1;  
        int low = 0;  
        int high = nums.length-1;  
          
        while(low<high){  
            int mid = low +(high - low)/2;  
            if(nums[mid] > target){  
                high = mid -1;  
            }else if(nums[mid] < target){  
                low = mid +1;  
            }else{  
                high = mid;  
            }  
        }  
        return nums[low] == target?low:-1;  
    }