常用算法 golang

常用算法 golang 

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

	}
	return -1
}

//二分查找(有相同的取最左边界)
func left_bin_search(nums []int, target int) int {
	left := 0
	right := len(nums) - 1

	for left <= right {
		mid := left + (right-left)/2
		if nums[mid] == target {
			right = mid - 1
		} else if nums[mid] < target {
			left = mid + 1
		} else if nums[mid] > target {
			right = mid - 1
		}
	}
	if left == len(nums) {
		return -1
	}
	if nums[left] != target {
		return -1
	}
	return left
}
//二分查找(有相同的取最右边界)
func right_bin_search(nums []int, target int) int {
	left := 0
	right := len(nums) - 1

	for left <= right {
		mid := left + (right-left)/2
		if nums[mid] == target {
			left = mid + 1
		} else if nums[mid] < target {
			left = mid + 1
		} else if nums[mid] > target {
			right = mid - 1
		}
	}
	if right < 0 {
		return -1
	}
	if nums[right] != target {
		return -1
	}
	return right
}


func lengthOfLongestSubstring(s string) int {
	retVal := -1
	window := make(map[byte]int)
	left, right := 0, 0
	for right < len(s) {
		c := s[right]
		right++
		window[c]++
		for window[c] > 1 {
			d := s[left]
			left++
			window[d]--
		}

		if right-left > retVal {
			retVal = right - left
		}
	}
	return retVal

}

// 四方向涂0
func dfs(x int, y int, grid [][]byte) {
	if grid[x][y] == 1 {
		grid[x][y] = 0
		if x > 0 {
			dfs(x-1, y, grid)
		}
		if x < len(grid)-1 {
			dfs(x+1, y, grid)
		}
		if y > 0 {
			dfs(x, y-1, grid)
		}
		if y < len(grid[x])-1 {
			dfs(x, y+1, grid)
		}
	}
}
//寻找岛屿
func solve(grid [][]byte) int {
	// write code here
	count := 0
	for i := 0; i < len(grid); i++ {
		for j := 0; j < len(grid[i]); j++ {
			if grid[i][j] == 1 {
				count++
				dfs(i, j, grid)
			}
		}
	}
	return count
}


// 版本号比较
func compare(version1 string, version2 string) int {
	// write code here
	len1 := len(version1)
	len2 := len(version2)
	i := 0
	j := 0
	for i < len1 || j < len2 {
		num1 := 0
		num2 := 0
		for i < len1 && version1[i] != '.' {
			num1 = num1*10 + int(version1[i]-'0')
			i++
		}
		i++
		for j < len2 && version2[j] != '.' {
			num2 = num2*10 + int(version2[j]-'0')
			j++
		}
		j++

		if num1 > num2 {
			return 1
		}

		if num1 < num2 {
			return -1
		}
	}

	return 0
}

func Min(x, y int) int {
	if x < y {
		return x
	}
	return y
}
//最小步长
func minCostClimbingStairs(cost []int) int {
	// write code here
	dp := make([]int, len(cost)+1)
	for i := 2; i < len(cost)+1; i++ {
		dp[i] = Min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
	}
	return dp[len(cost)]
}