LeetCode热题100道-Day01

1. 两数之和

• 使用map来存储数组的值与下标，然后遍历一遍目标数组，当遍历的数组的当前值存在与map中的值相加和为target时。说明该两数和符合题目要求，返回相应下标即可。

func twoSum(nums []int, target int) []int {
    m := make(map[int]int)
    for i:=0; i<len(nums); i++ {
        sum := target - nums[i]
        if v,ok := m[sum];ok {
            return []int{v, i}
        }
        m[nums[i]] = i
    }
    return []int{-1, -1}
}

2. 两数相加

• 同时遍历两个链表，若链表为nil则需要补0，然后累加，并进位即可。记得最后还要补充、判断最后一位是否存在进位

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    res := new(ListNode)
    p := res
    temp := 0
    for l1!=nil || l2!=nil {
        var t1,t2 int
        if l1==nil {
            t1 = 0
        } else {
            t1 = l1.Val
            l1 = l1.Next
        }
        if l2==nil {
            t2 = 0
        } else {
            t2 = l2.Val
            l2 = l2.Next
        } 
        sum := t1+t2+temp
        value := sum%10 
        temp = sum/10
        p.Next = &ListNode{Val:value}
        p = p.Next
    }
    if temp!=0 {
        p.Next = &ListNode{Val:temp}
    }
    return res.Next
}

3. 无重复字符的最长子串

• 双指针

func lengthOfLongestSubstring(s string) int {
   if len(s) == 0 {
      return 0
   }
   res := 0
   l := 0
   r := 1
   m := make(map[interface{}]int)
   m[s[0]] = 0
   for ; r < len(s); r++ {
      if v, ok := m[s[r]]; ok {
         if v > l {
            l = v
         }
         l++
      }
      max := r - l + 1
      if max > res {
         res = max
      }
      m[s[r]] = r
   }
   return res
}

5. 最长回文子串

• 遍历

func longestPalindrome(s string) string {
    resCount := 0
    res := ""
    for i:=0; i<len(s); i++ {
        temp := ""
        if i>0 {
            temp = isPalindrome(s, i-1, i)
            if len(temp)>resCount {
                resCount = len(temp)
                res = temp
            }
        }
        temp = isPalindrome(s, i, i)
        if len(temp)>resCount {
            resCount = len(temp)
            res = temp
        }
    }
    return res
}
// isPalindrome 从中间往两边找最长子串
func isPalindrome(s string, l, r int) string{
    if s[l]!=s[r] {
        return ""
    }
    for l-1>=0 && r+1<len(s) {
        if s[l-1]==s[r+1] {
            l--
            r++
        } else {
            break
        }
    }
    return s[l:r+1]
}

20. 有效的括号

• 使用了栈来判断

func isValid(s string) bool {
   stack := []byte{}
   for i := 0; i < len(s); i++ {
      c := s[i]
      if c == '{' || c == '(' || c == '[' {
         stack = append(stack, c)
      } else {
         if len(stack) == 0 {
            return false
         }
         top := stack[len(stack)-1]
         if (top == '(' && c == ')') ||
            (top == '[' && c == ']') ||
            (top == '{' && c == '}') {
            stack = stack[:len(stack)-1]
         } else {
            return false
         }
      }
   }
   if len(stack) == 0 {
      return true
   } else {
      return false
   }
}