1.两数之和--2. 两数相加--3. 无重复字符的最长子串

1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

func twoSum(nums []int, target int) []int {
    var ret []int
    valIndex:=make(map[int]int,len(nums))
    for i,v:=range nums{
        val,has:=valIndex[target-v]
        if has&&val!=i{
            ret=append(ret,i)
            ret=append(ret,valIndex[target-v])
            break
		}
		valIndex[v]=i
    }
    return ret
}

采用map存储切片中的值和切片的下标，每遇到一个数x，查询target-x作为key在map中是否存在，如果存在，而且其value和当前x的下标不相同，那么就找到了这两个数的下标了，否则将x和其下标一同插入到map中。

2. 两数相加

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

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

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

示例：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/add-two-numbers
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
	//由于链表逆序存储一个数的各个位，因此可以由前向后做加法
	ret := new(ListNode) //ret是一个*ListNode
	cur := ret
	var add int
	for l1 != nil || l2 != nil {
		if l1 != nil {
			add += l1.Val
			l1 = l1.Next
		}
		if l2 != nil {
			add += l2.Val
			l2 = l2.Next
		}
		cur.Next = &ListNode{add % 10, nil}
		add = add / 10
		cur = cur.Next
	}
	if add > 0 {
		cur.Next = &ListNode{add, nil}
	}
	return ret.Next
}

这个题思路很简单，就是按位相加，如果有进位，加上上一位的进位。可能存在的问题，主要是指针操作的问题。这里使用了一个空的头结点，cur和ret指向相同的空节点位置，增加的节点从ret.Next开始，最终返回ret.Next。

对于变量只定义不初始化，不能使用。
错误代码

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
	//由于链表逆序存储一个数的各个位，因此可以由前向后做加法
	ret := new(ListNode) //ret是一个*ListNode
	cur := ret
	var add int
	for l1 != nil || l2 != nil {
		if l1 != nil {
			add += l1.Val
			l1 = l1.Next
		}
		if l2 != nil {
			add += l2.Val
			l2 = l2.Next
		}
		cur = &ListNode{add % 10, nil}
		add = add / 10
		cur = cur.Next
	}
	if add > 0 {
		cur.Next = &ListNode{add, nil}
	}
	return ret
}

上述代码出错愿意:ret和cur初始均指向同一个空节点，在后续增加了新节点后，cur指向了新节点，而ret仍然指向开始时候的空节点，最终也只能返回空节点。

如果非要从第一个节点开始就存值，那可以使用二级指针：

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
	//由于链表逆序存储一个数的各个位，因此可以由前向后做加法
	var ret *ListNode
	cur := &ret
	var add int
	for l1 != nil || l2 != nil {
		if l1 != nil {
			add += l1.Val
			l1 = l1.Next
		}
		if l2 != nil {
			add += l2.Val
			l2 = l2.Next
		}
		*cur = &ListNode{add % 10, nil}
		add = add / 10
		cur = &((*cur).Next)
	}
	if add > 0 {
		*cur = &ListNode{add, nil}
	}
	return ret
}

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

给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
示例 2:

输入: “bbbbb”
输出: 1
解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。
示例 3:

输入: “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。
  请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-substring-without-repeating-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。