一、func hashStr(sep string) (uint32, uint32)

先分析下golang用得hash算法

32 bit FNV_prime = 2^24 + 2^8 + 0x93 = 16777619（詳見FNV hash算法）

// primeRK is the prime base used in Rabin-Karp algorithm.
const primeRK = 16777619
// hashStr returns the hash and the appropriate multiplicative
// factor for use in Rabin-Karp algorithm.
func hashStr(sep string) (uint32, uint32) {
    hash := uint32(0)
    for i := 0; i < len(sep); i++ {
        //hash = 0 * 16777619 + sep[i]
        hash = hash*primeRK + uint32(sep[i])
    }
    var pow, sq uint32 = 1, primeRK
    for i := len(sep); i > 0; i >>= 1 {
        if i&1 != 0 {
            pow *= sq
        }
        sq *= sq
    }
    return hash, pow
}

核心算法是這一句(FNV Hash算法)
hash = hash*primeRK + uint32(sep[i])
后面一段, 計(jì)算出pow（后面Index函數(shù)使用）,如下公式

var pow, sq uint32 = 1, primeRK
for i := len(sep); i > 0; i >>= 1 {
    if i&1 != 0 {
        pow *= sq
    }
    sq *= sq
}

二、func Index(s, sep string) int

這是golang strings包中的Index函數(shù)函數(shù), 查找sep字符串在s中的位置并返回（RK算法，Rabin-Karp算法）

// Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
func Index(s, sep string) int {
    //查找字符串的長(zhǎng)度
    n := len(sep)
    switch {
    //長(zhǎng)度 == 0， return 0
    case n == 0:
        return 0
    //長(zhǎng)度 == 1，調(diào)用另外一個(gè)函數(shù)
    case n == 1:
        return IndexByte(s, sep[0])
    //長(zhǎng)度 == s字符串的長(zhǎng)度相等，比較兩個(gè)字符串是否相等
    case n == len(s):
        if sep == s {
            return 0
        }
        return -1
    case n > len(s):
        return -1
    }
    // Rabin-Karp search

    hashsep, pow := hashStr(sep)
    var h uint32
    for i := 0; i < n; i++ {
        h = h*primeRK + uint32(s[i])
    }
    if h == hashsep && s[:n] == sep {
        return 0
    }
    for i := n; i < len(s); {
        h *= primeRK
        h += uint32(s[i])
        h -= pow * uint32(s[i-n])
        i++
        if h == hashsep && s[i-n:i] == sep {
            return i - n
        }
    }
    return -1
}

常規(guī)思路（sep是關(guān)鍵詞，s是源字符串）

1. 對(duì)要查找的字符串sep進(jìn)行hash，此處hash值是uint32類型
2. 在源字符串s中，從頭取len(sep)長(zhǎng)度，也進(jìn)行hash
3. 比較兩次hash值是否一致，一致，返回index

例如在“abcdefgh”中查找“fg”的位置

1. 對(duì)“fg” hash，得到hashsep
2. for循環(huán)，依次取2位（len("fg")），比如第一次取，“ab”， 第二次取“bc”， 第三次取“cd”..., 進(jìn)行hash，得到hashsep1
3. 比較hashsep和hashsep1是否相等

golang源碼中，使用的算法如下

1. 對(duì)要查找的字符串sep進(jìn)行hash，得到hashsep， 此處hashsep值是uint32類型
2. 在s頭部取len(sep)的字符串，進(jìn)行hash，直接與上步產(chǎn)生的hashsep比較，相等則已經(jīng)找到
3. 根據(jù)上步的hashsep計(jì)算出下次需要的hashsep

例如：
在“abcdefgh”中查找“fg”的位置

1. 對(duì)“fg” hash，得到hashsep

hashsep, pow := hashStr(sep)

2. 取出“ab”進(jìn)行hash，得到hash值，與hashsep比較

var h uint32
    for i := 0; i < n; i++ {
        h = h*primeRK + uint32(s[i])
    }
    if h == hashsep && s[:n] == sep {
        return 0
    }

3. 根據(jù)“ab”的hash值，計(jì)算出“bc”的hash值（這一步很巧妙）

for i := n; i < len(s); {
        h *= primeRK
        h += uint32(s[i])
        h -= pow * uint32(s[i-n])
        i++
        if h == hashsep && s[i-n:i] == sep {
            return i - n
        }
    }

分析一下怎么根據(jù)“ab”的hash值，計(jì)算出“bc”的hash值
還以“abcdefg”中查找“ef”為例

1. 計(jì)算hash["ab"] (表示“ab”的hash值)

2. 計(jì)算hash["bc"]

   
   
3. 從hash["ab"]計(jì)算出hash["bc"]

可以用多位字符串試一試，我這里只用兩位

對(duì)比一下剛才這段代碼

for i := n; i < len(s); {
        h *= primeRK
        h += uint32(s[i])
        h -= pow * uint32(s[i-n])
        i++
        if h == hashsep && s[i-n:i] == sep {
            return i - n
        }
    }

func hashStr(sep string) (uint32, uint32)函數(shù)返回的pow就是用來(lái)計(jì)算下一個(gè)組合的hash值的h -= pow * uint32(s[i-n])