1.求兩數之和（數組無序）

//方法一：暴力破解 時間o(n^2) 空間o(1)
func TwoNumSum1(nums []int, target int) []int {
    for i := 0; i < len(nums)-1; i++ {
        for j := i + 1; j < len(nums); j++ {
            if nums[i]+nums[j] == target {
                return []int{i, j}
            }
        }
    }
    return nil
}

//方法二：空間換時間 時間o(n)  空間o(n)
func TwoNumSum2(nums []int, target int) []int {
    result := make([]int, 0)
    realIndex := make(map[int]int)
    for i, v := range nums {
        if valueIndex, ok := realIndex[target-v]; ok {
            return append(result, valueIndex, i)
        } else {
            realIndex[v] = i
        }
    }
    return result
}

2.求電話號碼的字母組合

func letterCombinations(digits string) []string {
    m:=make(map[byte][]string)
    m['2']=[]string{"a","b","c"}
    m['3']=[]string{"d","e","f"}
    m['4']=[]string{"g","h","i"}
    m['5']=[]string{"j","k","l"}
    m['6']=[]string{"m","n","o"}
    m['7']=[]string{"p","q","r","s"}
    m['8']=[]string{"t","u","v"}
    m['9']=[]string{"w","x","y","z"}
    var ret []string
    for i:=0;i<len(digits);i++{
        ret=getCombination(ret,m[digits[i]])
    }
    return ret
}
func getCombination(a,b []string)[]string{
    if len(a)==0{
        return b
    }
    if len(b)==0{
        return a
    }
    var ret []string 
    for _,v:=range a{
        for _,bv:=range b {
            ret=append(ret,v+bv)
        }
    }
    return ret
}

3.三數之和

func ThreeNumsTwo(nums []int) [][]int {
    if len(nums) < 3 {
        return nil
    }
    sort.Ints(nums)
    fmt.Println(nums)
    flag := false
    for _, v := range nums {
        if v != 0 {
            flag = true
        }
    }
    //全0的情況
    if !flag {
        return [][]int{{0, 0, 0}}
    }
    result := make([][]int, 0)
    L := 0
    R := len(nums) - 1
    for i, v := range nums {
        //當前這個元素都大于0了，后面的元素加起來不可能等于0
        if nums[i] > 0 {
            return result
        }
        // 去除重復的元素排序后相鄰
        if i > 0 && nums[i] == nums[i-1] {
            continue
        }
        //每次進入重置指針
        L = i + 1
        R = len(nums) - 1
        for L < R {
            if 0 == nums[L]+nums[R]+v {
                result = append(result, []int{v, nums[L], nums[R]})
                //第二個元素重復的情況
                for L < R && nums[L] == nums[L+1] {
                    L++
                }
                //第三個元素重復的情況
                for L < R && nums[R] == nums[R-1] {
                    R--
                }
                L++
                R--
            } else if nums[L]+nums[R]+v < 0 {
                L++
            } else {
                R--
            }
        }

    }
    return result
}

4.兩數之和（鏈表）

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    if l1 == nil {
        return l2
    }
    if l2 == nil {
        return l1
    }
    head := &ListNode{
        Val: 0,
    }
    curr := head
    nextAdd := 0
    for l1 != nil || l2 != nil {
        x, y := 0, 0
        if l1 != nil {
            x = l1.Val
        }
        if l2 != nil {
            y = l2.Val
        }
        sum := x + y + nextAdd
        if nextAdd > 0 {
            nextAdd = 0
        }
        val := sum % 10
        nextAdd = sum / 10
        node := &ListNode{
            Val: val,
        }
        if l1 != nil {
            l1 = l1.Next
        }
        if l2 != nil {
            l2 = l2.Next
        }
        curr.Next = node
        curr = node
    }
    if nextAdd != 0 {
        node := &ListNode{
            Val: nextAdd,
        }
        curr.Next = node
        curr = node
    }
    return head.Next
}

5.合并有序數組

func merge(nums1 []int, m int, nums2 []int, n int)  {
//先拼接
    for i:= range nums2{
        nums1[i+m]=nums2[i]
    }
//再排序（冒泡）
    for i:=0;i<len(nums1);i++{
        for j:=i+1;j<len(nums1);j++{
            if nums1[i]>nums1[j]{
                temp:=nums1[i]
                nums1[i]=nums1[j]
                nums1[j]=temp
            }
        }
    }
//或者直接排序   sort.Ints(nums1)


}

6.移除指定元素

更改 nums 數組，使 nums 的前 k 個元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。

func removeElement(nums []int, val int) int {
    k:=0
    for i:=range nums{
        if nums[i]!=val{//不相等，說明這個元素需要保存下來
          nums[k]=nums[i]
          k++
        }

    }
    return k
}

7.刪除有序數組中的重復項

更改數組 nums ，使 nums 的前 k 個元素包含唯一元素，并按照它們最初在 nums 中出現的順序排列。nums 的其余元素與 nums 的大小不重要。

   func removeDuplicates(nums []int) int {
    count:=1 //從第二個元素開始替換
    for i:=0;i<len(nums)-1;i++{
        //碰到不相等的情況，說明不重復元素多了一個
         if nums[i]!=nums[i+1]{
          nums[count]=nums[i+1];//將后面的元素覆蓋數組的位置
          count++ //移動到下一個位置
         }
    }
    return count
}

8.買賣股票的最佳時機

func maxProfit(prices []int) int {
    if len(prices)==0{
        return 0
    }
    min:=math.MaxInt
    max:=0
    for i:=0;i<len(prices);i++{
       if prices[i]<min{
         min=prices[i] //記錄買入最小值
       } 
   //假設我現在賣出，獲取的利潤是不是最大，是就替換max
   if prices[i]-min>max{
            max=prices[i]-min
        }
    }
    return int(max)
}

9.驗證回文串

如果在將所有大寫字符轉換為小寫字符、并移除所有非字母數字字符之后，短語正著讀和反著讀都一樣。則可以認為該短語是一個 回文串 。
字母和數字都屬于字母數字字符。

func isPalindrome(s string) bool {
   str1 := ""
    for _, v := range s {
        if (v >= 'A' && v <= 'Z') || (v >= 'a' && v <= 'z') || (v >= '0' && v <= '9')  {
            str1 += string(v)
        }
    }
    r := strings.ToLower(str1)
    ll := len(r)
    for i := 0; i < ll/2; i++ {
        if r[i] != r[ll-i-1] {
            return false
        }
    }
     return true
}

10.多數元素（眾數）

給定一個大小為 n 的數組 nums ，返回其中的多數元素。多數元素是指在數組中出現次數 大于 ? n/2 ? 的元素。

你可以假設數組是非空的，并且給定的數組總是存在多數元素。

func majorityElement(nums []int) int {
  if len(nums)==0{
     return 0
  }
  cd:=nums[0] //眾數
  count:=1 //次數
  for i:=1;i<len(nums);i++{
    //如果和當前眾數相等，則+1
    if nums[i]==cd{
        count++
    }else {
        count--  //否則-1
    }
    //當count=0時，換一個眾數
    if (count<=0){
        cd=nums[i]
        count=1
    }
  }
  return cd
}