LeetCode_面试精选（Python）

刷LeetCode真是一个一眼望不到头的任务，为了秋招，只能先考虑搞定面试精选题。

46.全排列
题目描述：给定一个没有重复数字的序列，返回其所有可能的全排列。

代码：
回溯算法

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res=[]
        tmp=[]
        def backtrack(nums,tmp):
            if not nums:
                res.append(tmp)
                return
            for i in range(len(nums)):
                backtrack(nums[:i]+nums[i+1:],tmp+[nums[i]])
        backtrack(nums,tmp)
        return res

48. 数组中的第K个最大元素
题目描述：在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

代码：

class Solution(object):
    def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        nums_len=len(nums)
        nums1=sorted(nums)
        return nums1[nums_len-k]

55.跳跃游戏
题目描述：给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。

代码：
从前往后

class Solution(object):
    def canJump(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        nums_len=len(nums)
        start,end=0,0
        while start<=end and end<nums_len:
            end=max(end,nums[start]+start) 
            #end是可以达到的最大下标
            start+=1
        return end>=nums_len-1

从后往前

class Solution(object):
    def canJump(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        nums_len=len(nums)
        start=nums_len-2
        end=nums_len-1
        while start>=0:
            if start+nums[start]>=end:end=start 
        #在当前start下end是可以达到的
            start-=1
        return end<=0

73.矩阵置零
题目描述：给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。请使用原地算法。

进阶:
一个直接的解决方案是使用 O(mn) 的额外空间，但这并不是一个好的解决方案。
一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
你能想出一个常数空间的解决方案吗？

代码：
自己写的暴力解法,空间复杂度为O(m+n)

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        local=[]
        m=len(matrix)
        n=len(matrix[0])
        for i in range(m):
            for j in range(n):
                if matrix[i][j]==0:
                    local.append([i,j])
        for x in local:
            matrix[x[0]][:]=[0]*n
            for i in range(m):
                matrix[i][x[1]]=0
        return matrix

进阶：空间复杂度为O(1)

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        col_is=False
        m=len(matrix)
        n=len(matrix[0])
        for i in range(m):
            if matrix[i][0]==0:
                col_is=True
            for j in range(1,n):
                if matrix[i][j]==0:
                    matrix[i][0]=0
                    matrix[0][j]=0
        for i in range(1,m):
            for j in range(1,n):
                if matrix[i][0]==0 or matrix[0][j]==0:
                    matrix[i][j]=0
        if matrix[0][0]==0:
            for j in range(n):
                matrix[0][j]=0
        if col_is:
            for i in range(m):
                matrix[i][0]=0

105.从前序与中序遍历序列构造二叉树
题目描述：根据一棵树的前序遍历与中序遍历构造二叉树。

代码：

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution(object):
    def buildTree(self, preorder, inorder):
        """
        :type preorder: List[int]
        :type inorder: List[int]
        :rtype: TreeNode
        """
        if not preorder:return None
        root=TreeNode(preorder[0])
        mid=inorder.index(preorder[0])
        root.left=self.buildTree(preorder[1:mid+1],inorder[:mid])
        root.right=self.buildTree(preorder[mid+1:],inorder[mid+1:])
        return root

242.有效的字母异位词
题目描述：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

代码：

from collections import Counter
class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        s_dict=Counter(s)
        t_dict=Counter(t)
        for x in s_dict.keys():
            if x not in t_dict or t_dict[x]!=s_dict[x]:
                return False
        return True

用sorted函数一行判断

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        return sorted(s)==sorted(t)

287.寻找重复数
题目描述：
代码：
先排序，再找重复数字

class Solution(object):
    def findDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        nums.sort()
        nums_len=len(nums)
        for i in range(nums_len-1):
            if nums[i]==nums[i+1]:
                return nums[i]

• 我们看下数据结构，一个n+1大小的数组，数组内的元素为1~n,我们用1个索引对应一个相应的数字，例如数字1对应index1，那么肯定有多个数字对应了同一个index，那么这个index就是我们要找的重复数
• 因为我们不能用额外的空间，我们可以将这个特殊的数组想像成这样一个链表这个数据结构，链表结点的value为数组值，而同时链表的value又指向下一个链表结点。那么我们的问题可以抽象为在链表中找环的入口问题，使用一个fast指针和一个slow指针，先找到在环内的交点，然后从起点开始，和交点一起按照步长为1运动，最后的交点就是我们要找到重复数字

class Solution:
    def findDuplicate(self, nums) :
        slow,fast,start = 0,0,0
        while True:
            slow = nums[slow]
            fast = nums[nums[fast]]
            if slow == fast:
                break
        while start!=slow:
            start = nums[start]
            slow = nums[slow]
        return start