每日编程（六）--leetcode

题目：两数相加

题目描述：

给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

上代码：

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
   n := 0                                      //存放进位
    cur := &ListNode{}       //定义一个指针，存放第一个节点
    top := cur      //将第一个节点的值存放起来，返回
    for flag := true; l1 != nil || l2 != nil; {
        v1, v2 := 0, 0
        if l1 != nil {
            v1 = l1.Val   
        }

        if l2 != nil {
            v2 = l2.Val
        }

        val := v1 + v2 + n
        n = val / 10
        if flag {                         //判断是否是第一个节点
            cur.Val = val % 10    
        } else {   
            cur.Next = &ListNode{         //申请一个新地址
                Val: val % 10,
            }
            cur = cur.Next    //将新地址付给cur
        }

        if l1 != nil {
            l1 = l1.Next
        }
        if l2 != nil {
            l2 = l2.Next
        }

        flag = false
    }

    if n > 0 {             //看是否需要再进一位
        cur.Next = &ListNode{
            Val: 1,
        }
    }

    return top         
}   

题目：三数之和

题目表述：

给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
  [-1, 0, 1],
  [-1, -1, 2]
]

分析：利用map查重，方法比较笨，欢迎更加高效的办法

上代码：

func threeSum(nums []int) [][]int {
  if len(nums)<3{
        return [][]int{}
    }
    sort.Ints(nums)
    a:=[]int{}
    b:=[]int{}
    c:=[]int{}
    a_hash:=make(map[int]int)
    c_hash:=make(map[int]int)
    for _,v:=range nums{
        if v<0{
            a=append(a,v)
            a_hash[v]=v
        }else{
            if v==0{
                b=append(b,v)
            }
            c=append(c,v)
            c_hash[v]=v
        }
    }
    var res [][]int
    re_hash:=make(map[string]int)

    alen:=len(a)
    blen:=len(b)
    clen:=len(c)
    if blen>=3{
        res=append(res,[]int{0,0,0})
        re_hash["000"]=1
    }
    for i:=0;i<alen-1;i++{
        for j:=i+1;j<alen;j++{
           h:=-(a[i]+a[j])
           if _,ok:=c_hash[h];ok{
               temp:=[]int{a[i],a[j],h}
               key:=fmt.Sprint(temp,"")
               if _,ok:=re_hash[key];!ok{
                   re_hash[key]=1
                   res=append(res,temp)
            }
           }
        }
    }
    for i:=0;i<clen-1;i++{
        for j:=i+1;j<clen;j++{
            h:=-(c[i]+c[j])
            if _,ok:=a_hash[h];ok{
                temp:=[]int{c[i],c[j],h}
                key:=fmt.Sprint(temp,"")
                if _,ok:=re_hash[key];!ok{
                    re_hash[key]=1
                    res=append(res,temp)
                }
            }
        }
    }

return res
}
func Issame(s1 []int,s2 []int)bool{
    sort.Ints(s1)
    sort.Ints(s2)
    n :=len(s1)
    for i:=0;i<n;i++{
        if s1[i]!=s2[i]{
            return false
        }
    }
    return true
}