golang力扣刷题（一）

---

title: golang力扣刷题（一）
date: 2021-10-14 21:03:50
categories:

• go
  tags:
• 基础

---

力扣刷题（一）

力扣刷题 全部题目模块（1～30）

简单

山峰数组

符合下列属性的数组 arr 称为 山峰数组（山脉数组） ：arr.length >= 3存在 i（0 < i < arr.length - 1）使得：
arr[0] < arr[1] < … arr[i-1] < arr[i] arr[i] > arr[i+1] > … > arr[arr.length - 1] 给定由整数组成的山峰数组 arr ，返回任何满足 arr[0] < arr[1] < … arr[i - 1] < arr[i] > arr[i + 1] > … > arr[arr.length - 1] 的下标 i ，即山峰顶部。

示例 1：

输入：arr = [0,1,0]
输出：1

示例 2：

输入：arr = [1,3,5,4,2]
输出：2

func peakIndexInMountainArray(arr []int) int {
   
   
       var i,j int
       j=len(arr)-1
   for i=0;i<j;i++{
   
   
    if (arr[i]>arr[j]) {
   
   
         j=j-1
         i=i-1
    }
   }
   return i
}从
执行用时：8 ms, 在所有 Go 提交中击败了88.24%的用户
内存消耗：4.5 MB, 在所有 Go 提交中击败了16.18%的用户

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

func twoSum(nums []int, target int) []int {
   
   
    var i,j int
    //b:=[]int{}  这里定义的切片已经被赋值，切片是只读对象
    b:=make([]int, 2)    //var b []int
    for i=0;i<len(nums)-1;i++{
   
   
        for j=i+1;j<=len(nums)-1;j++{
   
   
            if(nums[i]+nums[j]==target){
   
               
              b[0]=i
              b[1]=j         
            }
        }
    }
    return b
}
执行用时：36 ms, 在所有 Go 提交中击败了9.31%的用户
内存消耗：3.7 MB, 在所有 Go 提交中击败了87.59%的用户

整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321

示例 2：

输入：x = -123
输出：-321

示例 3：

输入：x = 120
输出：21

func reverse(x int) int {
   
   
  n:=0
  for (x!=0){
   
   
      n=n*10+x%10
      x=x/10
  }
    if(n<(-2147483648))||(n>(2147483647)){
   
   
      n=0
  }
 // max := int(^uint32((0)) >> 1)
 // min := ^max
 // if(n<min)||(n>max){
   
   
 //     n=0
 // }
  //if(n<(-2^31))||(n>(2^31-1)){ //go语言中^表示按位异或  不是次方  pow(2, 32)
  //    n=0
  //}
  return n
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了64.87%的用户

无符号整型uint，其最小值是0，其二进制表示的所有位都为0，

const UINT_MIN uint = 0

其最大值的二进制表示的所有位都为1，那么，

const UINT_MAX = ^uint(0)

有符号整型int，根据补码，其最大值二进制表示，首位0，其余1，那么，

const INT_MAX = int(^uint(0) >> 1)

根据补码，其最小值二进制表示，首位1，其余0，那么，

const INT_MIN = ^INT_MAX

回文数

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。例如，121 是回文，而 123 不是。

示例 1：

输入：x = 121
输出：true

示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

func isPalindrome(x int) bool {
   i:=0
   a:=x
   if x<0{
   	return false
   }
   for x!=0{
	   i=i*10+x%10
	   x=x/10
   }
  if i==a{
  	return true
  }else {
  	return false
  }
}
执行用时：20 ms, 在所有 Go 提交中击败了47.91%的用户
内存消耗：4.9 MB, 在所有 Go 提交中击败了91.25%的用户

罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值

I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

func romanToInt(s string) int {
   
   
	var mm = []struct {
   
    
		value  string
		b int
	}{
   
   
		{
   
   "M", 1000},
		{
   
   "CM", 900},
		{
   
   "D", 500},
		{
   
   "CD", 400},
		{
   
   "C",100},
		{
   
   "XC", 90},
		{
   
   "L",50},
		{
   
   "XL", 40},
		{
   
   "X", 10},
		{
   
   "IX", 9},
		{
   
   "V", 5},
		{
   
   "IV",4},
		{
   
   "I",1},
	}
x:=0
var ss string
for j:=0;j<len(s);j++{
   
   
	if j+1<len(s) {
   
   
		ss = string(s[j]) + string(s[j+1]) //判断组合
	}else {
   
   
		ss="d"   //遍历从上到下"MDCXCV" 防止XC  在V前面计算
	}
	println(ss)
	for _,a:=range mm{
   
   

		if ss==a.value{
   
   
			x=x+a.b
			j=j+1    //for循环后面还要再++  所以+1
			break
		}
		if j==len(s){
   
   
			return x
		}
		if string(s[j])==a.value{
   
   
			x=x+a.b
			break
		}
	}
}
return x
}
执行用时：24 ms, 在所有 Go 提交中击败了15.05%的用户
内存消耗：3 MB, 在所有 Go 提交中击败了57.37%的用户

var symbolValues = map[byte]int{
   
   'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}

func romanToInt(s string) (ans int) {
   
   
    n := len(s)
    for i := range s {
   
   
        value := symbolValues[s[i]]
        if i < n-1 && value < symbolValues[s[i+1]] {
   
   
            ans -= value
        } else {
   
   
            ans += value
        }
    }
    return
}

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1：

输入：strs = ["flower","flow","flight"]
输出："fl"

func longestCommonPrefix(strs []string) string {
   
   
	x:=make([]rune,0,200)
	if strs == nil {
   
   
		return string(x)
	} else {
   
                //不为空时
		lens:=len(strs[0])
		for i:=0;i<len(strs);i++{
   
       //找出子串最小长度
            if lens>len(strs[i]){
   
   
            	lens=len(strs[i])
			}
		}
		i, j := 0, 0
		for j<lens {
   
                     //到最小长度停止
			d := strs[i][j]
			for i:=0;i < len(strs); {
   
       
				if d == strs[i][j] {
   
   
					i++
				} else {
   
   
					return string(x)
				}
				if i == len(strs) {
   
          //遍历到后面  加进去
					x = append(x, rune(d))
				}
			}
			j++
		}

	}
	return string(x)
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.3 MB, 在所有 Go 提交中击败了89.99%的用户

有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1：

输入：s = "()"
输出：true

type Stack struct {
   
               //定义栈
	size int
	top  int
	data []string
}
func isValid(s string) bool {
   
   
	s1 := Stack{
   
   }                  //初始化栈
	s1.size = len(s)
	s1.top = -1
	s1.data = make([]string, len(s))
	for _, a := range s {
   
                //遍历s
		var b string
		if string(a) == ")" {
   
              //设置出栈条件
			b = "("
		}
		if string(a) == "}" {
   
   
			b = "{"
		}
		if string(a) == "]" {
   
   
			b = "["
		}
		if s1.top > -1 && s1.data[s1.top] == b {
   
    //相等出栈
			s1.top--
		} else {
   
                                   //不等入栈
			s1.top++
			s1.data[s1.top] = string(a)
		}
	}
	if s1.top == -1 {
   
                                //判断栈空为true
		return true
	} else {
   
   
		return false
	}
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了17.24%的用户

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

func mergeTwoLists(L1 *ListNode, L2 *ListNode) *ListNode {
   
   
	L3 := &ListNode{
   
   -200, L1}               //设置L3.Next=L1
	head := L3                              //头指针
	for L1 != nil && L2 != nil {
   
   
		if L1.Val >= L2.Val {
   
                    // 指向小的
			head.Next = L2
			println(head.Val)
			head = head.Next
			L2 = L2.Next
		} else {
   
   
			head.Next = L1
			println(head.Val)
			head = head.Next
			L1 = L1.Next
		}
	}
	if L2 != nil {
   
                             //那个不为空 指向它 添到后面
		head.Next = L2
	}
	if L1 != nil {
   
   
		head.Next = L1
	}
	return L3.Next
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.5 MB, 在所有 Go 提交中击败了42.80%的用户

删除有序数组中的重复项

给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：
输入：nums = [1,1,2]
输出：2, nums = [1,2]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

func removeDuplicates(nums []int) int {
   
   
	var a, b int
	if len(nums) == 0 {
   
            //排除一些特殊情况
		return 0
	}
	if len(nums) == 1 {
   
   
		return 1
	} else {
   
   
		a = nums[0]
		j := 1
		for i := 1; i < len(nums); i++ {
   
   
			b = nums[i]
			if a != b {
   
                  //不相等的时候用b,去逐渐取代数组里面的值
				nums[j] = b             
				a = nums[j]
				j++
			}
		}
		return j
	}
}
执行用时：8 ms, 在所有 Go 提交中击败了84.52%的用户
内存消耗：4.3 MB, 在所有 Go 提交中击败了99.94%的用户

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：
输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

func removeElement(nums []int, val int) int {
   
   
	var b int
	j := 0
	for i := 0; i < len(nums); i++ {
   
   
		b = nums[i]
		if b != val {
   
   
			nums[j] = b
			j++
		}
	}
	return j
}
执行用时：0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗：2.1 MB, 在所有 Go 提交中击败了58.62%的用户

实现strStr()

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回 -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：
输入：haystack = "hello", needle = "ll"
输出：2

func strStr(haystack string, needle string) int {
   
   
	n := len(needle)
	falge := false
	m := -1
	if len(needle) == 0 {
   
       //排除特殊情况
		return 0
	}
	for a, b := range haystack {