跳跃表，LRU，KMP，BFPRT，Manacher算法

跳跃表

http://www.dannysite.com/blog/228/

https://cloud.tencent.com/developer/news/387722

 

LRU (least-recently used)

利用OrderedDict实现

利用dict+双端链表实现

https://www.cnblogs.com/zuoyuan/p/3701572.html

https://juejin.im/post/5a9e6835f265da23937697ea

 

KMP算法

https://www.cnblogs.com/yjiyjige/p/3263858.html

http://hanslen.me/2017/02/06/KMP-Algorithm-explanation-and-python-code/

python代码实现如下：

#KMP算法
def get_next_table(pat):     #根据子字符串，构造next表
    length = len(pat)
    next = [0]*length
    for i in range(1,length):
        k = next[i-1]
        while pat[k]!=pat[i] and k:
            k = next[k-1]
        if pat[k]==pat[i]:
            next[i]=k+1
    return next

def search_substring(str,pat):  #str为母字符串，pat为要寻找的子串
    i = 0
    j = 0
    next = get_next_table(pat)
    while i<len(str) and j<len(pat):
        if str[i]==pat[j]:
            i = i+1
            j = j+1
        else:
            if j==0:
                i = i+1
            else:
                j = next[j-1]
    if j==len(pat):
        return i-j     #若匹配，返回第一个字符的index
    return -1

pat = "abcabcdeas"
str="abcdeasedcaedabcabcdeasdcabeaddcabvbad"
print(get_next_table(pat))
index = search_substring(str,pat)
print(str[index:index+len(pat)])

 

BFPRT算法

https://zhuanlan.zhihu.com/p/31498036

作用：返回数组中第K大的数（采用了快速排序，但在pivot的选取上比较特殊）

python代码实现如下：

#BFPRT 算法

def bfprt(alist,left,right,k):  #返回alist中第K大的数
    if k<=0:
        return None
    pivot = find_mid(alist,left,right)
    index = partition(alist,left,right,pivot)
    temp = index-left+1
    if temp==k:
        return alist[index]
    elif temp>k:
        return bfprt(alist,left,index-1,k)
    else:
        return bfprt(alist,index+1,right,k-temp)
        
def find_mid(alist,left,right):
    if left+4>=right:  #当个数小于5时
        insert_sort(alist,left,right)
        return (left+right)/2
    i = left
    while i<right-5:  #每五个数为一组
        insert_sort(alist,left,left+4)
        swap(alist,left+i/5,i+2) 
        i = i+5
    num = right-i+1
    if num>0:   #处理分组剩下的数据
        insert_sort(alist,i,right)
        #print(left,right,left+i/5,(i+right)/2)
        swap(alist,left+i/5,(i+right)/2)    
    n = i/5
    if n<5:
        return left
    else:
        return find_mid(alist,left,left+n)
        
def insert_sort(alist,left,right):#插入排序
    
    for i in range(left+1,right):
        pos = i
        current = alist[i]
        while pos>0 and alist[pos-1]>alist[pos]:
            alist[pos]=alist[pos-1]
            pos = pos-1
        alist[pos]=current
        
def swap(alist,i,j):
    alist[i],alist[j]=alist[j],alist[i]
        
def partition(alist,left,right,pivot): #根据pivot值进行一次快排分组
    swap(alist,left,pivot)
    first = left+1
    last = right
    while first<=last:
        while first<=last and alist[first]<=alist[left]:
            first = first+1
        while first<=last and alist[last]>=alist[left]:
            last = last-1
        if first<last:
            swap(alist,first,last)
    swap(alist,left,last)
    return last
    
if __name__=="__main__":
    alist=[19,20,9,30,7,4,2,5,11,6,41,42,43,43,44,45,46,47,48,49,50,60,59,58,57,56,54,53,52,51]
    for i in range(len(alist)+1):
        f = bfprt(alist,0,len(alist)-1,i)  #依次打印出第1,2,3....10大的数
        print(f)

 

Manacher算法

https://segmentfault.com/a/1190000008484167

python代码如下：

#Manacher算法,  最长回文子串
def manacher(str):
    str = init(str)
    mx = 0
    max_length=0
    p=[0]*len(str)
    for i in range(1,len(str)):
        if i<mx:
            p[i]=min(p[2*id-i],mx-i)
        else:
            p[i]=1
        while (i-p[i])>=0 and (i+p[i])<len(str) and str[i-p[i]]==str[i+p[i]]:  #防止越界
            p[i]=p[i]+1    
        if mx<p[i]+i:
            id=i
            mx=p[i]+i
        max_length = max(max_length,p[i]-1)
    return max_length

#对字符串进行处理,"abbadba"处理成"#a#b#b#a#d#b#a#"
def init(str):
    temp=["#"]  
    for i in str:
        temp.append(i)
        temp.append("#")
    return "".join(temp)
if __name__=="__main__":
    print(manacher("abbadba"))   #4
    print(manacher("abbadbaabd"))  #6
    print(manacher("abbadbaabddddbaa")) #10
    print(manacher("abbadbaabcdefghijklmnopqqponmlkjihgfedcba")) #34