二分法

基本思路是利用查找中间值，将中间值和target比较，判断，target在左区间还是右区间， 如果nums[mid] > target ,则说明target在左区间

right赋值为mid – 1, 如果nums[mid] > target, 则说明target在右区间，更新left = mid + 1

func search(nums []int, target int) int {
    high := len(nums) - 1
    low := 0
    for low <= high {
        mid := low + (high-low)/2
        if nums[mid] == target {
            return mid
        } else if nums[mid] > target {
            high = mid - 1
        } else {
            low = mid + 1
        }
    }
    return -1
}

双指针法

定义两个指针，快指针可以在for循环 里，不用额外定义。慢指针要定义，两个都从0开始，如果快指针与目标值不相等则每一次慢指针递增一，如果相等，则慢指针停下，快指针在for循环递增，数组当前元素=数组当前索引对应的下一个元素。

func removeElement(nums []int, val int) int {
    l := len(nums)
    //fast := 0
    slow := 0
    for fast :=0; fast<l; fast ++{
        if val != nums[fast]{
            nums[slow] = nums[fast]
            slow ++
        }
    }
    return slow
}

leetcode 26

自己想的比较低效的一种写法
func removeDuplicates(nums []int) int {
    slow := 0
    l := len(nums)
    ln := len(nums)
    if ln == 0{
        return 0
    }
    if ln<2{
        return 1
    }
    for fast :=slow+1; fast<l; fast++{
        if nums[fast]== nums[slow]{
            for i:=slow; i<l-1;i++{
                nums[i] = nums[i+1]

            }
            fmt.Println("---")
            fmt.Println("l:", l)
            if nums[fast]==nums[slow]{
                fast--
                slow--
            }
            l --
        }
        slow ++
    }
    fmt.Println(nums)
    return l
}

借鉴了评论里一个大佬方案
func removeDuplicates(nums []int) int {

    slow := 0
    fast := 1
    l := len(nums)
    if l<2{
        return l
    }
    for fast<l{
        if nums[slow]!=nums[fast]{
            nums[slow+1]=nums[fast]
            slow ++
        }
        fast++
        //l--
    }
    return slow+1
}

对比了一下，我是对比如果相等的情况，而他的是对比不相等的情况，如果不相等那么把当前指针后一个索引的数字赋值为fast指向的数字，然后slow向后移一位，其他情况那么fast继续向后走。
leetcode844

堆栈
func backspaceCompare(s string, t string) bool {
    // 堆栈
    return build(s)==build(t)

}

func build(str string)string{
    s := []byte{}
    for i,v := range str{
        if v != 35{
            s = append(s, str[i])
        }else if len(s)>0{
            // fmt.Println("pop before:", string(s))
            s = append(s[:0], s[:len(s)-1]...)
            // fmt.Println("pop after:", string(s))
        }
    }
    return string(s)
}

双指针法
func backspaceCompare(s string, t string) bool {
    flagS, flagT := 0, 0
    i , j := len(s)-1, len(t)-1
    for i>=0||j>=0 {
        for i >= 0{
            if s[i] == 35 {
                flagS++
                i--
            } else if flagS > 0 {
                flagS--
                i--
            }else {
                // 这个时候说明遇到正常字符，不用去掉的那种，这个时候需要停下，让另一个循环执行， 如果两个字符相等那么继续，不相等直接返回false
                break
            }
        }
        for j >= 0{
            if t[j] == 35 {
                flagT++
                j--
            } else if flagT > 0 {
                flagT--
                j--
            }else{
                break
            }
        }
        if i>=0&&j>=0{
            if s[i]!= t[j]{
                return false
            }
        }else if i>=0||j>=0{
            return false
        }
        // 能坚持到这，说明都是被break了， 没有--
        i--
        j--
    }
    return true
}