200道大数据面试常考Leetcode算法题01-05（python带代码解析）

大家好，从本次开始，为大家推荐200道大数据面试常考Leetcode算法题，附带解析，都是从Leetcode官网总结大神们的解法（在这里感谢大神的帮助，我只是个搬运工！）每篇更新5篇，艾瑞巴迪和我一起刷起来！！

200道大数据面试常考Leetcode算法题01-两数之和

Leetcode原题为：

 题解为：

class Solution:
    def twoSum(self,nums,target):
        """
        :param nums: [3,2,4]
        :param target: 6
        :return: List[int] [1,2]
        """
        if not nums:  # 假如不存在nums数组，则返回None,提前做异常处理
            return None
        result = []  # 定义一个查询列表用于比较nums前后数的容器，
        for i in range(len(nums) - 1):  # 对nums列表进行循环
            result.append(nums[i])   # 每循环一个就装到result等待比对
            another_num = target - nums[i+1]  # targer减去当前循环数i的下一位
            if another_num in result:    # 判断targer减去当前循环数i的下一位的差是否在result里
                # 存在则保存relust列表中存在another_nums数的索引以及nums当前i下一个数的索引
                return [result.index(another_num), i + 1]

        return None

200道大数据面试常考Leetcode算法题02-两数相加

Leetcode原题为：

题解为：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        # 创建一个结点值为 None 的头结点, dummy 和 p 指向头结点, dummy 用来最后返回, p 用来遍历
        dummy = p = ListNode(None)          
        s = 0               # 每一步的求和暂存变量
        while l1 or l2 or s:
            # 如果 l1 或 l2 存在, 则取l1的值 + l2的值 + s(s初始为0, 如果下面有进位1, 下次加上)
            s += (l1.val if l1 else 0) + (l2.val if l2 else 0)  
            p.next = ListNode(s % 10)       # p.next 指向新链表, 用来创建一个新的链表
            p = p.next                      # p 向后遍历
            s //= 10                        # 有进位情况则取模, eg. s = 18, 18 // 10 = 1
            l1 = l1.next if l1 else None    # 如果l1存在, 则向后遍历, 否则为 None
            l2 = l2.next if l2 else None    # 如果l2存在, 则向后遍历, 否则为 None
        return dummy.next   # 返回 dummy 的下一个节点, 因为 dummy 指向的是空的头结点, 下一个节点才是新建链表的后序节点

200道大数据面试常考Leetcode算法题03-无重复字符的最长字串

Leetcode原题为：

题解为：

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        start, res, c_dict = -1, 0, {} # start为起始索引位置，res为返回的最大长度，c_dict为测试字典
        for i, c in enumerate(s):  # 对输入字符串进行循环，i为下标，c为字符
            if c in c_dict and c_dict[c] > start:  # 字符c在字典中 且 上次出现的下标大于当前长度的起始下标
                start = c_dict[c]  # 起始位置变成当前c_dict中存在的字符c的下标
                c_dict[c] = i   # 当前测试字典的c字符索引变为当前循环次数
            else:
                c_dict[c] = i  # 当前测试字典的c字符索引变为当前循环次数
                res = max(res, i-start) # 返回最大长度，res为上一个res，i-k为窗口大小，末减初，找出最大长度
        return res

200道大数据面试常考Leetcode算法题04-寻找两个正序数组的中位数

Leetcode原题为：

 题解为：

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        if len(nums1) > len(nums2):
            return self.findMedianSortedArrays(nums2, nums1)

        infinty = 2**40
        m, n = len(nums1), len(nums2)
        left, right = 0, m
        # median1：前一部分的最大值
        # median2：后一部分的最小值
        median1, median2 = 0, 0

        while left <= right:
            # 前一部分包含 nums1[0 .. i-1] 和 nums2[0 .. j-1]
            # // 后一部分包含 nums1[i .. m-1] 和 nums2[j .. n-1]
            i = (left + right) // 2
            j = (m + n + 1) // 2 - i

            # nums_im1, nums_i, nums_jm1, nums_j 分别表示 nums1[i-1], nums1[i], nums2[j-1], nums2[j]
            nums_im1 = (-infinty if i == 0 else nums1[i - 1])
            nums_i = (infinty if i == m else nums1[i])
            nums_jm1 = (-infinty if j == 0 else nums2[j - 1])
            nums_j = (infinty if j == n else nums2[j])

            if nums_im1 <= nums_j:
                median1, median2 = max(nums_im1, nums_jm1), min(nums_i, nums_j)
                left = i + 1
            else:
                right = i - 1

        return (median1 + median2) / 2 if (m + n) % 2 == 0 else median1

200道大数据面试常考Leetcode算法题05-最长回文子串

Leetcode原题为：

 题解为：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        
        size = len(s)
        # 特殊处理
        if size == 1:
            return s
        # 创建动态规划dynamic programing表
        dp = [[False for _ in range(size)] for _ in range(size)]
        # 初始长度为1，这样万一不存在回文，就返回第一个值（初始条件设置的时候一定要考虑输出）
        max_len = 1
        start = 0
        for j in range(1,size):
            for i in range(j):
                # 边界条件：
                # 只要头尾相等（s[i]==s[j]）就能返回True
                if j-i<=2:
                    if s[i]==s[j]:
                        dp[i][j] = True
                        cur_len = j-i+1
                # 状态转移方程 
                # 当前dp[i][j]状态：头尾相等（s[i]==s[j]）
                # 过去dp[i][j]状态：去掉头尾之后还是一个回文（dp[i+1][j-1] is True）
                else:
                    if s[i]==s[j] and dp[i+1][j-1]:
                        dp[i][j] = True
                        cur_len = j-i+1
                # 出现回文更新输出
                if dp[i][j]:
                    if cur_len > max_len:
                        max_len = cur_len
                        start = i

        return s[start:start+max_len]

好啦，这期的分享到这里结束啦！我们下期再见!