Go算法学习01——二分法和双指针法

2021-11-06 13:02:13 阅读：127 来源： 互联网

标签：01 return nums -- fast 二分法 int slow Go

二分法

基本思路是利用查找中间值，将中间值和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
}

标签：01,return,nums,--,fast,二分法,int,slow,Go
来源： https://blog.csdn.net/weixin_44154094/article/details/121135207

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Go算法学习01——二分法和双指针法

二分法

双指针法