LeetCode.1-10_Golang

Talk is cheap， show me your code.

1 两数之和

1. 需要使用map，因为map时间复杂度为O(1)。
2. map的key为值，map的value为数组的第几个
3. 题目中说：数组中同一个元素在答案里不能重复出现。所以必须遍历时放进去。

func twoSum(nums []int, target int) []int {
    // 使用map时间复杂度为1，key为值，value为index
    m := map[int]int{}  

    for i, j := range nums {
        need := target - j
        
        // 只有不存在的时候才放入。
        if v, ok := m[need]; ok {
            return []int{i, v}
        } else {
            m[j] = i
        }
    }
    return []int{}
}

总结：对时间复杂度要求严格，或者不会重复（要求或者自己认为），可以考虑是否用map

2 两数相加

1. 链表，倒序加和
2. 注意最后的进位即可，没什么好说的

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    now := 0
    answer := ListNode{}
    node := &answer

    for l1 != nil || l2 != nil {
        if l1 != nil {
            now += l1.Val
            l1 = l1.Next
        }
        if l2 != nil {
            now += l2.Val
            l2 = l2.Next
        }

        node.Next = &ListNode{Val: now%10}
        node = node.Next
        now /= 10
    }

    if now > 0 {
        node.Next = &ListNode{Val: now%10}
    }

    return answer.Next
}

总结：简单链表

3 无重复字符的最长子串

1. 双指针，滑动窗口
2. 将窗口内不重复的元素用map存储下来
3. 遇到重复的元素，把前指针后移，直到前指针的元素为后指针的元素，然后前指针再往前移一个

func lengthOfLongestSubstring(s string) int {
    m := map[byte]int{}
    now := 0
    answer := 0
    left := 0

    for i, b := range s {
        if _, ok := m[byte(b)]; !ok {
            now++
            if now > answer {
                answer = now
            }
            m[byte(b)] = 1
        } else {
            for ; left != i; left++ {
                if byte(b) == s[left] {
                    left++
                    break
                }
                delete(m, s[left])
                now--
            }
        }
    }
    return answer
}

总结：简单双指针

4