LeetCode刷题笔记（一）

1、Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

解：本题解题思路是建立一个Map列表，遍历一次array，将target与array成员相减得到的值作为Key，其下标作为Value。

再遍历一遍array，直到发现array的成员为Map的Key,则获取到二个下标，其成员相加为target。

func twoSum(nums []int, target int) []int {
	targetMap := make(map[int] int)
	for index, num := range(nums){
		targetMap[target-num] = index
	}
	for index, num := range(nums){
		value, ok := targetMap[num]
		if(ok == true && index != value){
			twoNums := []int{value, index}
			return twoNums
		}
	}
	fmt.Println(targetMap)
	return nil
}

2、You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

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

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

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

解：本题解题方向从表头开始相加，逢10进1，需要注意的是俩个List长度不一致导致的一些问题。

​ /* 以l2为主,逐成员计算 */
 func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
	add := false
	bl2 := true
	bl1 := true
	l3 := l2
	l4 := l2
	var i = 0
	for {
		if(add){
			l2.Val += l1.Val + 1
			add = false
		}else{
		l2.Val += l1.Val
		}	
		if(l2.Val >= 10){
			add = true
			l2.Val -= 10
		}else{
			add = false
		}
		if(l2.Val == 0 && add == false && bl1 == false && bl2 == false ){
			l4.Next = nil
			return l3
		}
		if(l2.Next == nil ){
			var node ListNode
			l2.Next = &node
			bl2 := false
		}else{
			bl2 := true
		}
		if(l1.Next == nil){
			var node ListNode
			l1.Next = &node	
			bl1 := false		
		}else{
			bl1 := true
		}
		i++
		l4 = l2
		l2 = l2.Next
		l1 = l1.Next
	}
	return nil
}

​

3、Given a string, find the length of the longest substring without repeating characters.

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。

请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

解：本题解体思路大致是设置左右指针指向一个string数组起始位置，并设置一个int数组映射，右指针开始向右移动，并将遍历过的成员记录到映射数组中，直到遇到重复成员，记录当前子集大小后。左指针开始右移动，并将遍历过的成员从映射数组中删除，直到遇到重复成员。重复上述步骤直到右指针遍历完string数组。

func lengthOfLongestSubstring(s string) int {
	var left, right, max int
	var flag [256]int 
	
	for ; right < len(s); right++{
		if(flag[s[right]] == 0){
			flag[s[right]] += 1  // 右指针遍历成员并记录到映射数组中
		}else{
			if(max < right - left){
				max = right - left  // 记录当前子集大小
			}			
			for s[left] != s[right]{
				flag[s[left]] -= 1  // 左指针遍历成员并从映射数组中删除
				left++
			}
			left++
		}
	}
	if(max < right - left){
		max = right - left
	}
	return max;
}

4、There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

You may assume nums1 and nums2 cannot be both empty.

给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。

请你找出这两个正序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

解：本题要求的时间复杂度为 O(log(m + n)),因此选用二分算法对二个数组进行计算。

func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {
	var m = len(nums1)
	var n = len(nums2)
	if n < m { // 确保nums1比nums2短，即确保m比n小
		var temp = nums1
		nums1 = nums2
		nums2 = temp
		m = len(nums1)
		n = len(nums2)
	}
	var midM = (m - 1) / 2
	var midN = (n - 1) / 2

	if m == 0 { // 处理长度为0的情况
		if n%2 == 1 {
			return float64(nums2[midN])
		}
		return float64(nums2[midN]+nums2[midN+1]) / 2
	}

	if m == 1 || m == 2 { // 边界条件
		if n < 3 { // n小于3的情况下，取nums2所有元素和nums1的元素进行排序
			for i := 0; i < n; i++ {
				nums1 = append(nums1, nums2[i])
			}
		} else if n%2 == 1 { // n大于2且为奇数的情况下，取nums2中间3位和nums1的元素进行排序
			for i := midN - 1; i < midN+2; i++ {
				nums1 = append(nums1, nums2[i])
			}
		} else { // 其他情况下，取nums2的中间4位和nums1的元素进行排序
			for i := midN - 1; i < midN+3; i++ {
				nums1 = append(nums1, nums2[i])
			}
		}
		sort.Ints(nums1)
		m = len(nums1)
		midM = (m - 1) / 2

		if len(nums1)%2 == 1 {
			return float64(nums1[midM])
		} else {
			return float64(nums1[midM]+nums1[midM+1]) / 2
		}
	}


	// n为奇数时，midNP==midN。n为偶数时，midNP==midN+1。
	var midNP = midN
	if n%2 == 0 {
		midNP++
	}

	if nums1[midM] == nums2[midNP] {
		return float64(nums1[midM])
	}
	if nums1[midM] < nums2[midNP] {
		//消除nums1数组0至midM-1下标的元素，和nums2数组n-midM下标之后的元素
		return findMedianSortedArrays(nums1[midM:], nums2[:n-midM])
	}
	//消除nums2数组0至midM-1下标的元素，和nums1数组n-midM下标之后的元素
	return findMedianSortedArrays(nums2[midM:], nums1[:m-midM])
}

5：Given a 32-bit signed integer, reverse digits of an integer.

、给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

解: 使用求余运算即可获取整数每一位的值

func reverse(x int) int {
    y := 0
    for x!=0 {
        y = y*10 + x%10
        x /= 10
	}
	if !( -(1<<31) <= y && y <= (1<<31)-1) {
		return 0
	}
    return y
}