leetcode刷题日记-热题100（1）

01-两数之和（python）
#比较/排序+指针

class Solution:
	def twosum(self,nums,target):
		for i in range(len(nums)):
			temp=nums[:i]
			if (target-nums[i]) in temp:
				j=temp.index(target-nums[i])
				break
		return [j,i]

03-无重复字符最长子串（python）
#滑动窗口

class Solution:
	def lengthOfLongestSubString(self,s):
		if not s:return 0
		lookup=set()
		max_len=0
		cur_len=0
		left=0
		for i in range(len(s)):
			cur_len+=1
			while s[i] in lookup:
				lookup.remove(s[left]
				cur_len+=1
			if cur_len>max_len:
				max_len=cur_len
			lookup.add(s[i])
		return max_len		

05-最长回文子串（python）
#动态规划-边界条件

class Solution:
	def longestPalindrome(self,s):
        size=len(s)
        if size<=1:
            return s
        longest_l=1
        res=s[0]
        dp=[[False for _ in range(size)] for _ in range(size)]
        for r in range(1,size):
            for l in range(r):
                if s[l] == s[r]:
                    if r - l < 3:
                        dp[l][r] = True
                    else:
                        dp[l][r] = dp[l + 1][r - 1]
                else:
                    dp[l][r] = False
                if dp[l][r]:
                    cur_len = r - l + 1
                    if cur_len > longest_l:
                        longest_l = cur_len
                        res = s[l:r + 1]
        return res

010-正则表达式匹配（python）

class Solution(object):
    def isMatch(self, s, p):
        if not p: return not s
        if not s and len(p) == 1: return False
        m, n = len(s) + 1, len(p) + 1
        dp = [[False for _ in range(n)] for _ in range(m)]
        # 初始状态
        dp[0][0] = True
        dp[0][1] = False
        for c in range(2, n):
            j = c - 1
            if p[j] == '*':
                dp[0][c] = dp[0][c - 2]        
        for r in range(1,m):
            i = r - 1
            for c in range(1, n):
                j = c - 1
                if s[i] == p[j] or p[j] == '.':
                    dp[r][c] = dp[r - 1][c - 1]
                elif p[j] == '*':       # ‘*’前面的字符匹配s[i] 或者为'.'
                    if p[j - 1] == s[i] or p[j - 1] == '.':
                        dp[r][c] = dp[r - 1][c] or dp[r][c - 2]
                    else:                       # ‘*’匹配了0次前面的字符
                        dp[r][c] = dp[r][c - 2] 
                else:
                    dp[r][c] = False
        return dp[m - 1][n - 1]

011-盛最多水的容器（python）
#双指针-移除短板

class Solution:
	def maxArea(self,height):
		i,j,res=0,len(height),0
		while i<j:
			if height[i]<height[j]:
				res=max(res,height[i]*(j-i))
				i+=1
			else:
				res=max(res,height[j]*(j-i))
				j-=1
		return res

015-三数之和（python）
#排序+双指针

class Solution:
    def threeSum(self, nums):
        nums.sort()
        res, k = [], 0
        for k in range(len(nums) - 2):
            if nums[k] > 0: 
                break # 1. because of j > i > k.
            if k > 0 and nums[k] == nums[k - 1]: 
                continue # 2. skip the same `nums[k]`.
            i, j = k + 1, len(nums) - 1
            while i < j: # 3. double pointer
                s = nums[k] + nums[i] + nums[j]
                if s < 0:
                    i += 1
                    while i < j and nums[i] == nums[i - 1]:
                         i += 1
                elif s > 0:
                    j -= 1
                    while i < j and nums[j] == nums[j + 1]:
                         j -= 1
                else:
                    res.append([nums[k], nums[i], nums[j]])
                    i += 1
                    j -= 1
                    while i < j and nums[i] == nums[i - 1]: 
                        i += 1
                    while i < j and nums[j] == nums[j + 1]: 
                        j -= 1
        return res

017-电话号码的字母组合（python）
#回溯

class Solution:
    def letterCombinations(self, digits):
        phone = {'2': ['a', 'b', 'c'],
            '3': ['d', 'e', 'f'],
            '4': ['g', 'h', 'i'],
            '5': ['j', 'k', 'l'],
            '6': ['m', 'n', 'o'],
            '7': ['p', 'q', 'r', 's'],
            '8': ['t', 'u', 'v'],
            '9': ['w', 'x', 'y', 'z']}
        output=[]    
        def backtrack(combination, next_digits):
            if len(next_digits)==0:
                output.append(combination)
            else:
                for letter in phone[next_digits[0]]:
                    backtrack(combination+letter,next_digits[1:])
        if digits:
            backtrack('',digits)
        return output

019-删除链表倒数第n个节点（python）
#快慢指针、求链表需要先建空链表

class Solution:
    def removeNthFromEnd(self, head, n):
        if not head:return
        dummy=ListNode(0)
        dummy.next=head
        fast=dummy
        slow=dummy
        for i in range(n):
            fast=fast.next
        while fast and fast.next:
            fast=fast.next
            slow=slow.next
        slow.next=slow.next.next
        return dummy.next

020-有效的括号（python）

class Solution:
    def isValid(self, s):
        mapping={")":"(","]":"[","}":"{"}
        stack=[]
        for char in s:
            if char not in mapping:
                stack.append(char)
            else:#判断右括号
                top_element=stack.pop()
                if top_element!=mapping[char]:
                    return false
        return not stack

21-合并两个有序链表（python）

class Solution:
    def mergeTwoLists(self, l1, l2):
        prev=ListNode(0)
        prehead=prev
        while l1 and l2:
            if l1.val<=l2.val:
                prehead.next=l1
                l1=l1.next
            else:
                prehead.next=l2
                l2=l2.next
            prehead=prehead.next
        prehead.next=l1 if l1 is not None else l2
        return prev.next

22-括号生成（python）
#回溯

class Solution:
	def generateParenthesis(self,n):
		ans=[]
		def backtrack(S='',left=0,right=0):
			if len(s)==2*n:
				ans.append(S)
			if left<n:backtrack(S='(',left+1,right)
			if right<left:backtrack(S=')',left,right+1)
		backtrack()
		return ans

23-合并k个有序链表（python）
#分治，先合并2个

class Solution:
    def mergeKLists(self, lists):
		if not lists:return 
        n = len(lists)
        return self.merge(lists, 0, n-1)
    def merge(self,lists, left, right):
        if left == right:
            return lists[left]
        mid = (left + right) // 2
        l1 = self.merge(lists, left, mid)
        l2 = self.merge(lists, mid+1, right)
        return self.mergeTwoLists(l1, l2)
    def mergeTwoLists(self, l1, l2):
        prev=ListNode(0)
        prehead=prev
        while l1 and l2:
            if l1.val<=l2.val:
                prehead.next=l1
                l1=l1.next
            else:
                prehead.next=l2
                l2=l2.next
            prehead=prehead.next
        prehead.next=l1 if l1 is not None else l2
        return prev.next

31-下一个排列（python）
#倒序查找第一个减小的索引，排序后，与第一个较大的值做交换。

class Solution:
    def nextPermutation(self, nums) :
		for i in range(len(nums)-1, 0, -1):
            if nums[i] > nums[i-1]:
                res_nums = nums[i:]
                res_nums.sort()
                nums[i:] = res_nums
                for j in range(i, len(nums)):
                    if nums[j] > nums[i-1]:
                        nums[j], nums[i-1] = nums[i-1], nums[j]
                        return nums
        nums.sort()
        return nums

32-最长有效的括号（python）

class Solution:
	def longestValidParenthesis(self,s):
		maxnum=0
		stack=[-1]
		for i in range(len(s)):
			if s[i]=='(':stack.append(i)
			else:
				stack.pop()
				if not stack:stack.append(i)
				if stack:maxnum=max(maxnum,i-stack[-1])
		return maxnum

33-搜索旋转排序数组（python）
#找下降索引，二分查找

class Solution:
    def search(self, nums, target):
        def find_rotate_index(left, right):
            if nums[left] < nums[right]:
                return 0            
            while left <= right:
                pivot = (left + right) // 2
                if nums[pivot] > nums[pivot + 1]:
                    return pivot + 1
                else:
                    if nums[pivot] < nums[left]:
                        right = pivot - 1
                    else:
                        left = pivot + 1
        def search(left, right):
            while left <= right:
                pivot = (left + right) // 2
                if nums[pivot] == target:
                    return pivot
                else:
                    if target < nums[pivot]:
                        right = pivot - 1
                    else:
                        left = pivot + 1
            return -1
        n = len(nums)        
        if n == 0:
            return -1
        if n == 1:
            return 0 if nums[0] == target else -1         
        rotate_index = find_rotate_index(0, n - 1)        
        if nums[rotate_index] == target:
            return rotate_index
        if rotate_index == 0:
            return search(0, n - 1)
        if target < nums[0]:
            return search(rotate_index, n - 1)
        else:
            return search(0, rotate_index)

34-在排序数组中查找元素的第一个和最后一个位置（python）
#二分查找（有重复值）

class Solution(object):
    def searchRange(self, nums, target):
        length = len(nums)
        if length == 0:
            return [-1,-1]
        left,right = 0,length-1
        while left <= right:
            mid = (left+right) // 2
            if nums[mid] == target:
                right = left = mid
                while left-1 >= 0 and nums[left-1] == target:
                    left -= 1
                while right+1 <= length-1 and nums[right+1] == target:
                    right += 1
                return [left,right]
            elif nums[mid] < target:
                left = mid + 1
            else:
                right = mid - 1
        return [-1,-1] 

39-组合总数（python）
#深度优先

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        size=len(candidates)
        if size==0:
            return []
        candidates.sort()
        path=[]
        res=[]
        self.dfs(candidates,0,size,path,res,target)
        return res
    def dfs(self,candidates,start,size,path,res,target):
        if target==0:
            res.append(path[:])
            return
        for index in range(start,size):
            ram=target-candidates[index]
            if ram<0:
                break
            path.append(candidates[index])
            self.dfs(candidates,index,size,path,res,ram)
            path.pop()

042-接雨水（python）
#双指针法

class Solution(object):
    def trap(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        if not height:return 0
        n=len(height)
        ans=0
        left,right=0,n-1
        max_left,max_right=height[0],height[n-1]
        while left<right:
            max_left=max(max_left,height[left])
            max_right=max(max_right,height[right])
            if max_left<max_right:
                ans+=max_left-height[left]
                left+=1
            else:
                ans+=max_right-height[right]
                right-=1
        return ans

46-全排列（python）
#递归+交换

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        def backtrack(first=0):
            if first==n:
                output.append(nums[:])
            for i in range(first,n):
                nums[first],nums[i]=nums[i],nums[first]
                backtrack(first+1)
                nums[first],nums[i]=nums[i],nums[first]
        output=[]
        n=len(nums)
        backtrack()
        return output

48-旋转图像（python）

class Solution:
	def rotate(self,matrix):
		n=len(matrix)
		for i in range(n):
			for j in range(i,n):
				matrix[i][j],matrix[j][i]=matrix[j][i],matrix[i][j]
		for i in range(n):
			matrix[i].reverse()
		return matrix

128-最长连续序列（python）

class Solution:
	def longestConsecutive(self,nums):
		if not nums:return 0
		nums.sort()
		longest_streak=1
		current_streak=1
		for i in range(1,len(nums)):
			if nums[i]!=nums[i-1]:
				if nums[i]==nums[i-1]+1:
					current_streak+=1
				else:
					longest_streak=max(longest_streak,current_streak)
					current_streak=1
		return max(longest_streak,current_streak)