leetcode刷题记录

46 全排列

import copy

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        ret=[]
        track=[]
        self.backtrack(nums,track,ret)
        return ret
        
    def backtrack(self,nums,track,ret):
        if(len(nums)==len(track)):
            ret.append(copy.deepcopy(track))
            return
        
        for i in range(len(nums)):
            if(nums[i] in track):
                continue
            else:
                track.append(nums[i])
                self.backtrack(nums,track,ret)
                track.pop(len(track)-1)
        return

            
            
                

77 组合

import copy

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        ret=[]
        track=[]
        self.backtrack(ret,track,1,n,k)
        return ret
    
    def backtrack(self,ret,track,start,n,k):
        if(len(track)==k):
            ret.append(copy.deepcopy(track))
            return
        for i in range(start,n+1):
            track.append(i)
            self.backtrack(ret,track,i+1,n,k)
            track.pop(len(track)-1)
        return

78 子集

数学归纳法：

import copy

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        l=len(nums)
        if(l==0):
            return [[]]
        end=nums.pop(l-1)
        ret=self.subsets(nums)
        for i in range(len(ret)):
            ret.append(copy.deepcopy(ret[i]))
            ret[len(ret)-1].append(end)
        return ret

回溯算法：

import copy

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        res=[]
        track=[]
        self.backtrack(nums,0,track,res)
        return res
    
    def backtrack(self,nums,start,track,res):
        res.append(copy.deepcopy(track))
        for i in range(start,len(nums)):
            track.append(nums[i])
            self.backtrack(nums,i+1,track,res)
            track.pop(len(track)-1)
        return

94 二叉树的中序遍历

class Solution:
    def inorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        def recur(self,ret,root):
            if(root==None):
                return
            recur(self,ret,root.left)
            ret.append(root.val)
            recur(self,ret,root.right)
            return
        ret=[]
        recur(self,ret,root)
        return ret

136 只出现一次的数字

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        ret=0
        for item in nums:
            ret^=item
        return ret

191 位1的个数

class Solution(object):
    def hammingWeight(self, n):
        """
        :type n: int
        :rtype: int
        """
        ret=0
        while(n>0):
            n=n&(n-1)
            ret=ret+1
        return ret

231 2的幂

class Solution(object):
    def isPowerOfTwo(self, n):
        """
        :type n: int
        :rtype: bool
        """
        if(n<=0):
            return False
        return (n&(n-1))==0