字符串分割的实现

最近看书时，突然想到，字符串分割应该很简单，毕竟是常用的函数，如果不使用语言提供的原生方法，怎么实现字符串的分割？

发现坑也有几个，直接码代码吧，简单的用go语言实现了一下。

func split(str , seg string) []string  {
    st := []rune(str)
    sr := []rune(seg)
    L := make([]int,len(st)/2+1) //起始位置索引
    R := make([]int,len(st)/2+1) //结束位置索引

    n:=0//分割计数
    a:=0//上一次的位置
    for i:=0; i <= len(st)-len(sr); i++ {//注意长度
        b := true
        
        for j:=0 ; j < len(sr); j++ {    
            if st[i+j]!=sr[j]{
                b=false
                break
            }    
        }
        if b{
            L[n]=a
            R[n]=i
            a=i+len(sr)
            i=a
            n++
        }
    }
    var ss []string
    if n!=0{
        L[n]=a　　//注意：可分割时，不要忘了最末尾的那一个
        R[n]=len(st)
        ss = make([]string,n+1)
        for i := 0; i <= n; i++ {
            x := L[i]
            y := R[i]        
            ss[i] = string(st[x:y])
        }
        return ss
    }
    ss = make([]string,1)　　//不能分割的话，也应该返回
    ss[0] = str
    return ss
}

 上面的示例有许多性能优化空间，主要是减少内存分配次数。用了个Count啊，⊙︿⊙

func GenSplit(str, seg string) []string {
    c := strings.Count(str, seg)
    if c == 0 {
        ss := make([]string, 1)
        ss[0] = str
        return ss
    }
    ss := make([]string, c+1)
    strLen := len(str)
    segLen := len(seg)
    a := 0 //上一次的位置
    n := 0
    //
    for i := 0; i <= strLen-segLen; i++ {
        if str[i] != seg[0] {
            continue
        }
        b := true
        for j := 0; j < segLen; j++ {
            if str[i+j] != seg[j] {
                b = false
                break
            }
        }
        if b {
            ss[n] = str[a:i]
            a = i + segLen
            i = a
            n++
        }
    }
    ss[n] = str[a:]
    return ss
}

和golang原生的方法比较了下，还是有点差距，看来golang的性能，真的是够浪的。