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
}

Leetcode In Golang

LeetCode Problems' Solutions