2021-03-LeetCode-简单

1. 两数之和

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        result = []
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if (nums[i]+nums[j]) == target:
                    result.append(i)
                    result.append(j)
                    return result

哈希

​
def execute(numbers, target):
    hashdict = dict()
    for index,value in enumerate(numbers, start=1):
        if target-value in hashdict:
            return [hashdict[target-value], index]
        hashdict[numbers[index-1]] = index
    return []

numbers = [1,2,3,9,4,10,6]
target = 8
execute(numbers, target)

7. 整数反转 

import math
class Solution:
    def reverse(self, x: int) -> int:
        
        s = str(x)
        # s = x
        a = []
        a_rev = []

        for i in s:
            # print(i)
            a.append(i)
            
        a.reverse()
        if a[-1] == '-':
            a_rev.append('-')
            for i in a[:-1]:
                a_rev.append(i)
        else:
            for i in a:
                a_rev.append(i)
        # print(a_rev)
        
        result = ''
        for i in a_rev:
            result+=i
        result = int(result)
        if result >= (math.pow(2, 31))-1 or result <= (math.pow(-2, 31)):
            return 0
        return result

20. 有效的括号

class Solution:
    def isValid(s: str) -> bool:
        a = ['0']
        x = ['(', '{', '[']
        y = ['()', '{}', '[]']
        for i in s:
            if a != [] and (a[-1]+i) in y:
                a.pop()
            else:
                a.append(i)
                continue
        if a == ['0']:
            return True
        else:
            return False
        
Solution.isValid("](]")

73. 矩阵置零 

class Solution:
    def setZeroes(matrix):
        """
        Do not return anything, modify matrix in-place instead.
        """
        hang = list()
        lie = list()
        for i in range(len(matrix)):
            y = 0  # 列
            for j in matrix[i]:
                if j == 0:
                    hang.append(i)
                    lie.append(y)
                y += 1

        hang = list(set(hang))
        lie = list(set(lie))
        
        for h in hang:
            matrix[h] = len(matrix[h]) * [0]
        for l in lie:
            for i in range(len(matrix)):
                matrix[i][l] = 0
                
        # print(matrix)
        

# matrix = [[1,1,1],[1,0,1],[1,1,1]]
matrix = [[0,1,2,0],[3,4,5,2],[1,3,0,5],[1,3,1,5],[0,3,1,5],[1,3,1,5],[1,3,1,5]]
Solution.setZeroes(matrix)

class Solution:
    def setZeroes(matrix):
        """
        Do not return anything, modify matrix in-place instead.
        """
        hang = list()
        lie = list()
        for i in range(len(matrix)):
            y = 0  # 列
            for j in matrix[i]:
                if j == 0:
                    hang.append(i)
                    lie.append(y)
                y += 1

        hang = list(set(hang))
        lie = list(set(lie))
        
        matrix_trans = list(map(list, zip(*matrix)))  # 转置
        for l in lie:
            matrix_trans[l] = len(matrix_trans[l]) * [0]
        
        matrix = list(map(list, zip(*matrix_trans)))  # 转置
        for h in hang:
            matrix[h] = len(matrix[h]) * [0]   
            
        print(matrix)

面试题 02.02. 返回倒数第 k 个节点 

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

class Solution:
    def kthToLast(self, head: ListNode, k: int) -> int:
        count = 0
        p = head
        while p:
            count += 1
            p = p.next
        for i in range(0, count - k):
            head = head.next
        return head.val

python位运算

异或：如果同一位的数字不同则为 1，相同则为 0。

1. 任何数和本身异或则为 0
2. 任何数和 0 异或是 本身
3. 异或满足交换律。 即 a ^ b ^ c ，等价于 a ^ c ^ b

剑指 Offer 65. 不用加减乘除做加法 

int add(int num1, int num2)
{
    int tmp1 = num1^num2;
    int tmp2 = (num1&num2)<<1;
    while(tmp2)
    {
        num1 = tmp1^tmp2;
        num2 = (tmp1&tmp2)<<1;
        tmp1= num1;
        tmp2= num2;
     }
     return tmp1;
}

原理分析：

以63加1为例，如下程序打印了位运算的过程(tmp1 和  tmp2 的二进制值)：

tmp1用来存放两个数相加(不进位)的结果，tmp2用来存放两个数相加的进位。那么number1加number2即可等效为tmp1加tmp2，由于tmp2是通过或运算再移位得来的，最终一定为为零，那么tmp1就是我们求的两数相加结果。

python3:

class Solution:
    def add(self, a: int, b: int) -> int:
        num1 = (a^b)&0xFFFFFFFF #step1:相加但不计进位的结果，因python无位数限制，在此将其限定在32位
        num2 = ((a&b)<<1)&0xFFFFFFFF #step2:求出进位结果，并将其转成32位
        while(num2): #step3:当有进位时，需要将step1和step2的结果继续相加，即重复step1和stwp2.
            a = (num1^num2)&0xFFFFFFFF
            b = ((num1&num2)<<1)&0xFFFFFFFF
            num1 = a
            num2 = b
        return num1 if num1<=0x7FFFFFFF else ~(num1^0xFFFFFFFF)

# 注意：8位可以表示的数值范围在 -128到+127，即（100000000-01111111），第一位是符号位。
# 所以32位可以表示的数值范围在 1000 0000 0000 0000 0000 0000 0000 0000到0x7FFFFFFF，即-2147483648到2147483647
# 但是python没有位数限制，即不存在最高位溢出，不会将表示负数的最高位‘1’认为是符号位，所以会将1000 0000 0000 0000 0000 0000 0000 0000认为是2147483648。
# 因此需要进行越界检查，将负数进行相应处理： ~(num1^0xFFFFFFFF)

参考：https://www.cnblogs.com/wmlj/p/10388270.html

136. 只出现一次的数字

题目大意是除了一个数字出现一次，其他都出现了两次，让我们找到出现一次的数。我们执行一次全员异或即可。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        temp = sum(set(nums))*2
        return temp-sum(nums)

上述方法都具有线性时间复杂度。需要额外使用 O(n) 的空间，其中 n 是数组长度。

位运算 

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        return reduce(lambda x, y: x ^ y, nums)

def singleNumber(self, nums: List[int]) -> List[int]:
    x = 0
    for num in nums:  # 1. 遍历 nums 执行异或运算
        x ^= num      
    return x;         # 2. 返回出现一次的数字 x

作者：jyd
链接：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/solution/jian-zhi-offer-56-i-shu-zu-zhong-shu-zi-tykom/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

137. 只出现一次的数字 II

题目大意是除了一个数字出现一次，其他都出现了三次，让我们找到出现一次的数。 灵活运用位运算是本题的关键。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        res = 0
        for i in range(32):
            cnt = 0  # 记录当前 bit 有多少个1
            bit = 1 << i  # 记录当前要操作的 bit
            for num in nums:
                if num & bit != 0:
                    cnt += 1
            if cnt % 3 != 0:
                # 不等于0说明唯一出现的数字在这个 bit 上是1
                res |= bit

        return res - 2 ** 32 if res > 2 ** 31 - 1 else res

剑指 Offer 56 - I. 数组中数字出现的次数

260. 只出现一次的数字 III（同解）

题目大意是除了两个数字出现一次，其他都出现了两次，让我们找到这个两个数。要求：时间复杂度O(N) ，空间复杂度 O(1) 的解法。

class Solution:
    def singleNumbers(self, nums: List[int]) -> List[int]:
        x, y, n, m = 0, 0, 0, 1
        for num in nums:         # 1. 遍历异或
            n ^= num
        while n & m == 0:        # 2. # m 循环左移一位，直到 n & m ！= 0
            m <<= 1       
        for num in nums:         # 3. 遍历 nums 分组
            if num & m: x ^= num # 4. 当 num & m != 0
            else: y ^= num       # 4. 当 num & m == 0
        return x, y              # 5. 返回出现一次的数字

645. 错误的集合

空间复杂度 O(1) 的解法

class Solution:

    def findErrorNums(self, nums: List[int]) -> List[int]:
        ret = 0  # 所有数字异或的结果
        a = 0
        b = 0
        for n in nums:
            ret ^= n
        for i in range(1, len(nums) + 1):
            ret ^= i
        # 找到第一位不是0的
        h = 1
        while(ret & h == 0):
            h <<= 1
        for n in nums:
            # 根据该位是否为0将其分为两组
            if (h & n == 0):
                a ^= n
            else:
                b ^= n
        for n in range(1, len(nums) + 1):
            # 根据该位是否为0将其分为两组
            if (h & n == 0):
                a ^= n
            else:
                b ^= n
        for num in nums:
            if a == num:
                return [a, b]
            if b == num:
                return [b, a]

作者：fe-lucifer
链接：https://leetcode-cn.com/problems/shu-zu-zhong-shu-zi-chu-xian-de-ci-shu-lcof/solution/zhi-chu-xian-yi-ci-de-shu-xi-lie-wei-yun-suan-by-a/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

190. 颠倒二进制位

class Solution:
    def reverseBits(self, n: int) -> int:
        res = 0
        for i in range(32):
            res = (res << 1) | (n & 1)
            n >>= 1
        return res

思路： 

   n      res
11001001  -
1100100   1
110010    10
(res << 1) | (n & 1)
n >>= 1

191. 位1的个数

class Solution:
    def hammingWeight(self, n: int) -> int:
        ret = sum(1 for i in range(32) if n & (1 << i)) 
        return ret