Leetcode In Golang

96
SpiffyEight77
2018.11.29 21:30 字数 650
LeetCode

LeetCode Problems' Solutions

LeetCode Problems

ID Title 中文名称 Solutions Difficulty
1 Two Sum 两数之和 C++ Go Easy
13 Roman to Integer 罗马数字转整数 C++ Go Easy
26 Remove Duplicates from Sorted Array 删除排序数组中的重复项 C++ Go Easy
48 Rotate Image 旋转图像 C++ Go Medium
58 Length of Last Word 最后一个单词长度 C++ Go Easy
66 Plus One 加一 C++ Go Easy
118 Pascal's Triangle 杨辉三角 C++ Go Easy
122 Best Time to Buy and Sell Stock II 买卖股票的最佳时机 II C++ Go Easy
125 Valid Palindrome 验证回文串 C++ Go Easy
136 Single Number 只出现一次的数字 C++ Go Easy
189 Rotate Array 旋转数组 C++ Go Easy
217 Contains Duplicate 存在重复元素 C++ Go Easy
283 Move Zeroes 移动零 C++ Go Easy
344 Reverse String 反转字符串 C++ Go Easy
496 Next Greater Element I 下一个更大元素 I C++ Go Medium
498 Diagonal Traverse 对角线遍历 C++ Go Medium
724 Find Pivot Index 寻找数组的中心索引 C++ Go Easy
739 Daily Temperatures 每日温度 C++ Go Medium
747 Largest Number At Least Twice of Others 至少是其他数字两倍的最大数 C++ Go Easy
832 Flipping an Image 翻转图像 C++ Go Easy
905 Sort Array By Parity 按奇偶排序数组 C++ Go Easy
921 Minimum Add to Make Parentheses Valid 使括号有效的最少添加 C++ Go Medium
946 Validate Stack Sequences C++ Go Medium

1. Two Sum

题意:给出一个数组(数字不重复)和目标值,输出数组元素和为目标值的两个元素的下标,当且仅当只有一个解。
思路:
1.暴力算法 两层for循环计算目标值 时间复杂度O(N^2) 空间复杂度O(1)
2.使用哈希表 通过哈希表查值 时间复杂度O(N) 空间复杂度O(N)
3.双指针 时间复杂度O(N^2) 空间复杂度O(1)
代码:

暴力算法
func twoSum(nums []int, target int) []int {
    for i := 0; i < len(nums); i++ {
        for j := i + 1; j < len(nums); j++ {
            if nums[i]+nums[j] == target {
                res := []int{i, j}
                return res
            }
        }
    }
    return nil
}

哈希表
func twoSum(nums []int, target int) []int {
    dict := make(map[int]int)
    for i := 0; i < len(nums); i++ {
        if v, ok := dict[nums[i]]; ok {
            res := []int{v, i}
            return res
        }
        dict[target-nums[i]] = i
    }
    return nil
}

双指针
func twoSum(nums []int, target int) []int {
    i, j := 1, 0
    slice := make([]int, 0, 2)
    for {
        if nums[i]+nums[j] == target {
            slice = append(slice, j)
            slice = append(slice, i)
            return slice
        }
        i++
        if i == len(nums) {
            j++
            i = j + 1
        }
        if j == len(nums) {
            return slice
        }
    }
}

13. Roman to Integer

题意:给出一个罗马字符串,输出罗马字符和。
思路:
1.暴力算法 switch case或者if计算总和 时间复杂度O(N) 空间复杂度O(1)
2.找规律 如果i+1的字符大于i先把i对应的值减去然后加上i+1的值 时间复杂度O(N) 空间复杂度O(1)
代码:

暴力算法
func romanToInt(s string) int {
    tmpMap := map[string]int{"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
    score := 0
    for i := 0; i < len(s); i++ {
        if i != len(s)-1 && string(s[i]) == "I" && string(s[i+1]) == "V" {
            score += 4
            i++
        } else if i != len(s)-1 && string(s[i]) == "I" && string(s[i+1]) == "X" {
            score += 9
            i++
        } else if i != len(s)-1 && string(s[i]) == "X" && string(s[i+1]) == "L" {
            score += 40
            i++
        } else if i != len(s)-1 && string(s[i]) == "X" && string(s[i+1]) == "C" {
            score += 90
            i++
        } else if i != len(s)-1 && string(s[i]) == "C" && string(s[i+1]) == "D" {
            score += 400
            i++
        } else if i != len(s)-1 && string(s[i]) == "C" && string(s[i+1]) == "M" {
            score += 900
            i++
        } else {
            score += tmpMap[string(s[i])]
        }
    }
    return score
}

找规律
func romanToInt(s string) int {
    score := 0
    dict := map[rune]int{'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
    res := []rune(s)

    for i := 0; i < len(s)-1; i++ {
        if dict[res[i]] < dict[res[i+1]] {
            score -= dict[res[i]]
        } else {
            score += dict[res[i]]
        }
    }
    score += dict[res[len(s)-1]]
    return score
}

344. Reverse String

题意:给出一个字符串,输出翻转字符串后结果
思路:
1.暴力算法 for循环交换值 时间复杂度O(N) 空间复杂度O(N)
代码:

暴力算法
func reverseString(s string) string {
    res := []rune(s)
    for i := 0; i < len(s)/2; i++ {
        res[i], res[len(s)-i-1] = res[len(s)-i-1], res[i]
    }
    return string(res)
}

532. K-diff Pairs in an Array

题意:给出一个数组和数字k找出数组中差为k的数字对数目
思路:
1.双指针(慢速) 先排序,然后通过嵌套哈希表来查找数字对 时间复杂度O(N^2) 空间复杂度O(N)
2.哈希表 时间复杂度O(N) 空间复杂度O(N)
代码:

双指针
func findPairs(nums []int, k int) int {
    zeroCount, count, l, r := 0, 0, 0, 1

    if len(nums) == 0 || k < 0 {
        return 0
    }

    for i := 0; i < len(nums); i++ {
        if nums[i] == 0 {
            zeroCount++
        }
    }
    if zeroCount == len(nums) && k == 0 && len(nums) > 1 {
        return 1
    } else if zeroCount == len(nums) && k == 0 {
        return 0
    }

    dict := make(map[int]map[int]bool)
    sort.Ints(nums)
    for {
        if r > len(nums)-1 {
            break
        }

        if nums[r]-nums[l] == k || nums[l]-nums[r] == k {
            if !dict[nums[r]][nums[l]] && !dict[nums[l]][nums[r]] {
                pairs := make(map[int]bool)

                pairs[nums[l]] = true
                dict[nums[r]] = pairs

                pairs[nums[r]] = true
                dict[nums[l]] = pairs

                //dict[nums[r]][nums[l]] = true
                //dict[nums[l]][nums[r]] = true
                count++
            }
        }
        r++

        if r > len(nums)-1 {
            l++
            r = l + 1
        }

        if l > len(nums)-1 {
            break
        }
    }
    return count
}

哈希表
func findPairs(nums []int, k int) int {
    if k < 0 {
        return 0
    }

    res := 0
    dict := make(map[int]int)
    for i := 0; i < len(nums); i++ {
        dict[nums[i]]++
    }
    for key,_ := range dict {
        v := dict[key+k]
        if k == 0 && v == 1 || v == 0 {
            continue
        }
        res++
    }
    return res
}

682. Baseball Game

题意:给出一个字符数组,根据字符功能要求,输出得分结果
思路:
1.栈模拟 时间复杂度O(N) 空间复杂度O(N)
代码:

栈模拟
func calPoints(ops []string) int {
    var score int
    slice := make([]string, 0, len(ops))
    for i, j := 0, -1; i < len(ops); i++ {
        switch ops[i] {
        case "C":
            num, _ := strconv.Atoi(slice[j])
            score -= num
            slice = append(slice[:j])
            j--
        case "D":
            num, _ := strconv.Atoi(slice[j])
            score += num * 2
            t := strconv.Itoa(num * 2)
            slice = append(slice, t)
            j++
        case "+":
            a, _ := strconv.Atoi(slice[j])
            b, _ := strconv.Atoi(slice[j-1])
            score = score + a + b
            num := strconv.Itoa(a + b)
            slice = append(slice, num)
            j++
        default:
            num, _ := strconv.Atoi(ops[i])
            score += num
            slice = append(slice, ops[i])
            j++
        }
    }

    return score
}

832. Flipping an Image

题意:给出一个多维数组A,每个元素内先左右翻转,然后每行翻转
思路:
1.暴力 每行元素翻转,再每行翻转 时间复杂度O(N^2) 空间复杂度O(N)
代码:

暴力
func flipAndInvertImage(A [][]int) [][]int {
    for i := 0; i < len(A); i++ {
        for j := 0; j < len(A)/2; j++ {
            t := A[i][j]
            A[i][j] = A[i][len(A)-j-1]
            A[i][len(A)-j-1] = t
        }
    }

    for i := 0; i < len(A); i++ {
        for j := 0; j < len(A); j++ {
            A[i][j] = A[i][j] ^ 1
        }
    }
    return A
}

844. Backspace String Compare

题意:给出两个字符串S和T,#为退格键,然后输出最后的两个字符串结果是否相等
思路:
1.栈模拟 遇到#就弹栈 时间复杂度O(N) 空间复杂度O(N)
代码:

栈模拟
func backspaceCompare(S string, T string) bool {
    s := make([]string, 0, 200)
    t := make([]string, 0, 200)

    for i, j := 0, 0; i < len(S); i++ {
        if string(S[i]) == "#" && j > 0 {
            s = append(s[:j-1])
            j--
        } else if string(S[i]) != "#" {
            s = append(s, string(S[i]))
            j++
        }
    }

    for i, j := 0, 0; i < len(T); i++ {
        if string(T[i]) == "#" && j > 0 {
            t = append(t[:j-1])
            j--
        } else if string(T[i]) != "#" {
            t = append(t, string(T[i]))
            j++
        }
    }

    S = strings.Join(s, "")
    T = strings.Join(t, "")

    if S == T {
        return true
    }
    return false
}

905. Sort Array By Parity

题意:给出一个非负数组A,输出任意所有偶数在前所有奇数在后的结果
思路:
1.暴力 时间复杂度O(N) 空间复杂度O(1)
代码:

func sortArrayByParity(A []int) []int {
    tmp := 0
    for i, j := 0, 0; i < len(A); i++ {
        if A[i]%2 == 0 {
            tmp = A[j]
            A[j] = A[i]
            A[i] = tmp
            j++
        }
    }
    return A
}
Algorithm
Gupao