9月1日刷题:1-4

 

1. 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

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

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dict1 = {}    # 定义一个字典用来存储nums中遍历过的元素
        for i in range(len(nums)):
            num = target - nums[i]
            if num not in dict1:
                dict1[nums[i]] = i
            else:
                return [dict1[num], i]

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

示例：

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

# Definition for singly-linked list.
class ListNode(object):

    def __init__(self, x):
        self.val = x
        self.next = None

    def print_node(self):
        print(self.val)


class Solution(object):

    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 新建一个ListNode：值都是0
        head = ret = ListNode(0)

        # 当l1 和 l2不为空时（或不等于0）
        while l1 and l2:
            # ret的指针指向l1与l2的和值
            ret.next = ListNode(l1.val + l2.val)
            # l1指向下一个值
            l1 = l1.next
            # l2指向下一个值
            l2 = l2.next
            # ret还是0.节点指向下一个节点
            ret = ret.next

        # 当l2位数小于l1时
        while l1:
            ret.next = ListNode(l1.val)
            l1 = l1.next
            ret = ret.next

        # 当l1位数小于l2时
        while l2:
            ret.next = ListNode(l2.val)
            l2 = l2.next
            ret = ret.next

        # 处理进位
        ret = head = head.next
        while head:
            if head.val > 9:
                if head.next == None:                   # 判断下一个位置是否有数字
                    head.next = ListNode(0)
                head.next.val += int(head.val / 10)     # 进位
                head.val %= 10                          # 当前位置的数
            head = head.next
        print(ret)
        return ret                                      # 返回第一个位置的数


if __name__ == '__main__':

    l1 = ListNode(2)
    l1.next = ListNode(4)
    l1.next.next = ListNode(3)
    # l1.print_node()


    l2 = ListNode(5)
    l2.next = ListNode(6)
    l2.next.next = ListNode(4)
    # l2.print_node()

    solution = Solution()
    l3 = solution.addTwoNumbers(l1, l2)

    l3.print_node()
    l3.next.print_node()
    l3.next.next.print_node()

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

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

示例 1:

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

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

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

这道题主要用到思路是：滑动窗口
    什么是滑动窗口？其实就是一个队列,比如例题中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列
变成了 abca，这时候不满足要求。所以，我们要移动这个队列！
    如何移动？我们只要把队列的左边的元素移出就行了，直到满足题目要求！一直维持这样的队列，找出队列出现最长的长度时候，
求出解！
    时间复杂度：O(n)

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        res = ''
        maxlen = 0
        for ch in s:
            if ch not in res:
                res += ch
            else:
                maxlen = max(maxlen, len(res))
                index = res.index(ch)
                res = res[index + 1:] + ch
        return max(maxlen, len(res))


if __name__ == '__main__':
    solution = Solution()
    # print(solution.lengthOfLongestSubstring('abdcagt'))
    print(solution.lengthOfLongestSubstring('abcabcbb'))
    print(solution.lengthOfLongestSubstring('bbbb'))
    print(solution.lengthOfLongestSubstring('pwwkew'))

关于以下代码执行成功，提交报错的分析：

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        nums = sorted(nums1+nums2)
        if len(nums)%2 ==0:
            answer = (nums[int(len(nums)/2-1)]+nums[int(len(nums)/2)])/2
        else:
            answer = nums[int((len(nums)+1)/2)-1]
        return answer

解析：这是Python版本的问题。Python2.x和python3.x的语法差异造成的。

 

 

在Python3.0中变成真除法（无论任何类型都会保持小数部分，即使整除也会表示为浮点数形式）。 

>>> 3/2

1.5

>>> 3/2.0

1.5

>>> 4/2

2.0

>>> 4/2.0

2.0