leetcode实战

1 二数之和（wly2020-10-11）

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解：
第一种方式暴力破解法 （时间复杂度01）

func twoSum(nums []int, target int) []int {
//计算出数组的长度
len := len(nums)
for i:=0;i<len - 1;i++{
for j:= i + 1;j<len;j++{
if nums[i] + nums[j] == target{
return []int{i,j}
}
}
}
return []int{}
}

第二种方式(时间复杂度o(n))，通过hash表的方式
func twoSum(nums []int, target int) []int {
mapArray := make(map[int]int)
//1 定义一个map数组
//2 每次用目标值-当前的这个值看看是否在map中
for i:=0;i<len(nums);i++{
v := nums[i];
if k,ok := mapArray[target - v];ok{
return []int{k,i}
}
mapArray[v] = i;
}
return []int{}
}

或者用这种方式

func twoSum(nums []int, target int) []int {
mapArray := make(map[int]int)
//1 定义一个map数组
//2 每次用目标值-当前的这个值看看是否在map中
for i,v := range nums{
if k,ok := mapArray[target - v];ok{
return []int{k,i}
}
mapArray[v] = i;
}
return []int{}

}

2 三数之和（swj 2020-10-11）

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组

示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

package solution
import (
“sort”
“strconv”
)
// 核心思想（不排序）：
// 1. 在第一层循环，从头开始遍历元素，相同的元素，跳过
// 2. 在第二层循环，记录前两次比较的大小
// 3. 在第三层循环，判断三个数的和是否为0
// 4. 对三个元素从小到大，依次插入切片中
// 5. 判断切片是否在目标切片中，采用map[string]bool{}来记录存在的切片（注意：这里使用relect来判断切片是否相等会导致time limit exceeded）
// 时间复杂度：O(n^3) 空间复杂度: O(n1) n1为结果的切片长度
func ThreeSum(nums []int) [][]int {
isSearch := map[int]bool{}
isVisited := map[string]bool{}
res := [][]int{}
for i := 0; i < len(nums); i++ {
if _, ok := isSearch[nums[i]]; ok {
continue
}
for j := i + 1; j < len(nums); j++ {
maxNum := nums[j]
minNum := nums[i]
if nums[j] < nums[i] {
maxNum = nums[i]
minNum = nums[j]
}
tmpArr := []int{}
sum := nums[i] + nums[j]
for k := j + 1; k < len(nums); k++ {
if sum+nums[k] == 0 {
tmpStr := “”
if nums[k] > maxNum {
// nums[k] > maxNum > minNum
tmpArr = append(tmpArr, minNum, maxNum, nums[k])
tmpStr += strconv.Itoa(minNum) + strconv.Itoa(maxNum) + strconv.Itoa(nums[k])
} else if nums[k] > minNum {
// maxNum > nums[k] > minNum
tmpArr = append(tmpArr, minNum, nums[k], maxNum)
tmpStr += strconv.Itoa(minNum) + strconv.Itoa(nums[k]) + strconv.Itoa(maxNum)
} else {
// maxNum > minNum > nums[k]
tmpArr = append(tmpArr, nums[k], minNum, maxNum)
tmpStr += strconv.Itoa(nums[k]) + strconv.Itoa(minNum) + strconv.Itoa(maxNum)
}
if _, ok := isVisited[tmpStr]; !ok {
res = append(res, tmpArr)
isVisited[tmpStr] = true
}
break
}
}
}
isSearch[nums[i]] = true
}
return res
}

package main
import (
“fmt”
“os”
“sort”
“strconv”
)
func main(){
nums := []int{-1, 0, 1, 2, -1, -4}
res := ThreeSumOpt(nums)
fmt.Println(res)
}
// 核心思想（排序）：
// 1. 先对数组进行排序
// 2. 在第一层循环中，从头开始遍历元素，相同的元素，跳过
// 3. 在第二层循环中，只要j(j=i+1)<k(k=len-1),当三个数之和小于0，j++；当三个数之和大于0，k–；当三个数之和等于0，j++,k–,并且记录三个数；
// 注意点：判断切片是否在目标切片中，采用map[string]bool{}来记录存在的切片（注意：这里使用relect来判断切片是否相等会导致time limit exceeded）
// 时间复杂度：O(n^2) 空间复杂度: O(n1) n1为结果的切片长度
func ThreeSumOpt(nums []int) [][]int {
sort.Ints(nums)
isSearch := map[int]bool{}
isVisited := map[string]bool{}
res := [][]int{}
for i := 0; i < len(nums); i++ {
if _, ok := isSearch[nums[i]]; ok {
continue
}
j := i + 1
k := len(nums) - 1
for {
if j >= k {
break
}
tmpArr := []int{}
if nums[i]+nums[j]+nums[k] < 0 {
j++
} else if nums[i]+nums[j]+nums[k] > 0 {
k–
} else {
tmpArr = append(tmpArr, nums[i], nums[j], nums[k])
tmpStr := strconv.Itoa(nums[i]) + strconv.Itoa(nums[j]) + strconv.Itoa(nums[k])
if _, ok := isVisited[tmpStr]; !ok {
res = append(res, tmpArr)
isVisited[tmpStr] = true
}
j++
k–
}
}
isSearch[nums[i]] = true
}
fmt.Println(isSearch)
return res
}

3 两数相加（zyw 2020-10-18）

https://leetcode-cn.com/problems/add-two-numbers/
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

4 有效的字母异位词（wy 2020-10-18）

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

示例 1:

输入: s = “anagram”, t = “nagaram”
输出: true
示例 2:

输入: s = “rat”, t = “car”
输出: false