LeetCode刷题记录

1. 求两数之和
   难度：简单
   题目描述：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
   你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

代码：

func twoSum(nums []int, target int) []int {
//使用map记录数组和编号
   var numMap map[int]int = make(map[int]int)
   var ints []int
   for i := 0 ;i < len(nums);i++{
       numMap[nums[i]] = i
   }   
   for i := 0 ;i < len(nums);i++{
   //遍历数组后，num的值即为和值减去当前遍历值
       num := target - nums[i]
       /*
       判断num值在map数据中是否存在，这里map的value用interface{}我觉得好点
       然后判断数组序号是否和map集合一致，一致则跳过
       */
       if numMap[num] != 0 && numMap[num] != i{
           ints = append(ints,i)
           ints = append(ints,numMap[num])
       }
       //由于题目设定只有一个答案，所以数组长度为2时终止遍历
       if len(ints) == 2{
           break;
       }
   }   
   return ints
}

结果：运行时间4ms,内存占用3.9mb

2. 两数相加

难度：中等
题目描述：给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：

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

代码：

//因为这道题自己没什么思路，因此使用别人的代码来解析
type ListNode struct {
	Val int
	Next *ListNode
}
//设置结构体
func main(){
	var l1 = new(ListNode)
	var l11 = new(ListNode)
	var l12 = new(ListNode)
	var l2 = new(ListNode)
	var l21 = new(ListNode)
	var l22 = new(ListNode)
	l1.Val = 8
	l11.Val = 9
	l12.Val = 7
	l12.Next = new(ListNode)
	l11.Next = l12
	l1.Next = l11
	l2.Val = 1
	l21.Val = 1
	l22.Val = 3
	l22.Next = new(ListNode)
	l21.Next = l22
	l2.Next = l21
	//l1即为798，l2即为311
	code := addTwoNumbers(l1,l2)
	fmt.Println(code)
}
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
/*
dummy是 哨兵节点（不在此节点操作，结果返回dummy.Next使用）、 curr 是当前真实要操作的节点，
curr := dummy 表示curr 指向dummy节点， 操作从curr.Next开始，
curr.Next = new(ListNode) 新建当前节点的下一个节点 curr = curr.Next 并将curr指向它
*/
    dummy := new(ListNode)
    curr := dummy
    carry := 0
    
    for (l1 != nil || l2 != nil || carry > 0) {
    //curr.Next = new(ListNode) 是操作的真实头节点
        curr.Next = new(ListNode)
        curr = curr.Next
        if l1 != nil {
            carry += l1.Val
            //通过ListNode = ListNode.Next 实现链表迭代
            l1 = l1.Next
        }
        if l2 != nil {
            carry += l2.Val
            l2 = l2.Next
        }
        curr.Val = carry % 10 
        carry /= 10
    }
    return dummy.Next
}

结果：运行时间16ms,内存占用5mb

3. 整数反转
   难度：简单
   题目描述：给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
   假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

示例：

输入：输入: 120
输出: 21

输入: -123
输出: -321

代码：

//设置结构体
func main(){
	//任意设置一个int32位
	var num1 int =  26495978
	var num int
	for {
		//num1%10可以获取最低位
		//当循环第一次的时候 num*10等于0,num1%10等于8,num结果8,num1结果2649597
		//之后以此类推得到反转数
		num =num*10 + num1 % 10
		num1 = num1 / 10
		//先将num转为int32，然后再转为int64,如果int32超出范围，转为int64时会反转符号
		if int(int32(num)) != num{
			num = 0
			break
		}
		if num1 == 0 {
			break
		}
	}
	fmt.Println(num)
}

结果：运行时间4ms,内存占用2.1mb

4. 寻找两个正序数组的中位数

难度：困难
进阶：设计一个时间复杂度为 O(log (m+n)) 的算法**(未实现)**
题目描述：给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。
示例：

输入：nums1 = [1,3], nums2 = [2]
输出：2.00000
解释：合并数组 = [1,2,3] ，中位数 2

代码：

func main(){
	nums1 := []int{1}
	nums2 := []int{}
	//用于存放两个集合
	var nums3 = make([]int, len(nums1)+len(nums2))
	var mid float64
	for i :=0;i<len(nums1);i++{
		nums3[i] = nums1[i]
	}
	for i :=0;i<len(nums2);i++{
		nums3[len(nums1)+i] = nums2[i]
	}
	sort.Ints(nums3)
	if len(nums3) % 2 == 0{
		x := (len(nums3)+1)/2
		y := (len(nums3)-1)/2
		mid = (float64((nums3[x] + nums3[y])) / 2)
	}else {
		mid = float64(nums3[(len(nums3)+1)/2-1])
	}
	fmt.Println(nums3)
	fmt.Println(mid)
}

结果：运行时间20ms,内存占用6.1mb