22年36周

目录

一：反转字符串

二：反转字符串II

三：替换空格

 四、翻转字符串里的单词

---

一：反转字符串

题目链接：反转字符串

思路：这道题有两个想法，（1）直接利用递归法进行反转
                                           （2）利用双指针法进行反转

//递归法

func reverseString(s []byte)  {

    if len(s) <= 1 {
        return
    }

    temp := s[0]
    s[0] = s[len(s)-1]
    s[len(s) - 1] = temp

    reverseString(s[1:len(s)-1])

}

二：反转字符串II

链接：反转字符串II

思路：这道题和上一道思路一样，只不过多了几处逻辑处理的地方。
（ps：写这道题时，由于运算符优先级没记住，导致一处bug好长时间没有被发现，最后打断点才发现的）

还有一个比我这个更好的思路就是，每次直接把index加2k的值，而不是像我这样是迭代方法进行的。

func reverseStr(s string, k int) string {

    res := []byte(s)

    last := 0 //记录上一次2k截取的值在哪里

    for index,_ := range res {
        if (index+1) % (2*k) == 0 {
            reverseStrK(res[last:last+k])
            last = index + 1
        }
        if index == len(res) - 1 && index+1 != last{//解决不足2k的问题
            if index - last + 1 > k {
                reverseStrK(res[last:last+k])
            }else {
                reverseStrK(res[last:index+1])
            }
        }
    }
   
    return string(res)
}

func reverseStrK(s []byte) {
    if len(s) <= 1 {
        return
    }

    temp := s[0]
    s[0] = s[len(s)-1]
    s[len(s) - 1] = temp

    reverseStrK(s[1:len(s)-1])
}

三：替换空格

题目链接：替换空格

思路：比较简单的思路是，直接新生成一个数组，遍历原来的数组，把数组元素一个个的填写进来。
比较极致的方法是，先计算里面共有多少个空格，之后把数组进行扩容操作，再之后在已经扩容的数组之上从后向前重新填写数组数据。

func replaceSpace(s string) string {

    res := make([]byte,0) 

    for _,v := range s {
        if v != ' ' {
            res = append(res,byte(v))
        }else {
            res = append(res,'%','2','0')
        }
    }
    return string(res)
}

 四、翻转字符串里的单词

链接：翻转字符串里的单词

思路：把字符串切割，并去除掉空格，在倒序遍历字符串数组。

还有一个比较奇特的思路，就是先去掉字符串中的多余的空格，之后把这个字符串进行逆转，之后再逆转单个单词，就达到了目的。

 

//常规方法
import "strings"
func reverseWords(s string) string {

    strs := strings.Fields(s)//去除s中的空格，并返回字符串切片
    //Split方法切割字符串的过程中，不会给多个空格字符串（“   ”）全都切割的
    res := make([]string,0)

    for i:=len(strs)-1;i>=0;i-- {
        res = append(res,strs[i])
    }

    result := strings.Join(res," ")
    return result

}

//奇特思路

import "strings"
func reverseWords(s string) string {
    s = strings.Trim(s," ")
    bytes := []byte(s)
    lenth := removeKongGe(bytes)
    bytes = bytes[:lenth]
    reverse(bytes)
    i := 0
    j := 0
    for j < len(bytes) {
        if bytes[j] != ' ' {
            j++
        }else {
            reverse(bytes[i:j])
            j++
            i = j
        }
        
    }
    reverse(bytes[i:j])
    return string(bytes)
}

func reverse(s []byte){
    i := 0
    j := len(s) - 1
    for i < j {
        temp := s[i]
        s[i] = s[j]
        s[j] = temp
        i++
        j--
    }
}

func removeKongGe (s []byte) int{
    i,j := 0,0
    for j<len(s){
        if j > 0 && s[j] == ' ' && s[j-1] == ' '{
            j++
            continue
        }else {
            s[i] = s[j]
            i++
            j++
        }
    }
    return i
}