LeetCode力扣1

简单组 python，100，1，7，9

100.相同的树

给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

1 |      1         1           1        1             1         1
2 |     / \       / \         /          \           / \       / \
3 |     2   3     2   3      2            2     	2   1     1   2
4 |
5 |    [1,2,3],   [1,2,3]   [1,2],  [1,null,2]    [1,2,1],   [1,1,2]
return:    1. true     			2.false					3.false

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
        if p == None and q == None:
            return True
        elif p == None or q == None:
            return False
        elif p.val != q.val:
            return False
        else:
             return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)        

补充：None与 NULL(即空字符)的区别
表示该值是一个空对象，空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
None表示没有，它是NoneType类的对象，你可以把它看成是一个具体的值。正因它是一个具体的值，所以它可以用来初始化变量
NULL = “”,空的。不会打印。 python3中没有NULL

1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解法：暴力搜索

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i, j]
# 以下是本地测试代码，提交时只需复制上面的代码块即可
solution = Solution()
nums = [2, 7, 11, 15]
target = 9
print(solution.twoSum(nums, target))

7:整数反转

给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

示例 1:
输入: 123
输出: 321

示例 2:
输入: -123
输出: -321

示例 3:
输入: 120
输出: 21

注意:假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。

class Solution:
    def reverse(self, x: int) -> int:
    #将整数的绝对值转换成字符串
        s=str(abs(x))
        #翻转字符串
        s=s[::-1]
        #如果输入整数是负数，增加负号
        if x <0:
            s ='-' + s
        #转换为整数
        result = int(s)
        #判断是否溢出
        if result>=-2**31 and result<=2**31-1:
            return result
        else:
            return 0

9 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

示例 1:
输入: 121
输出: true

示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。

示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

进阶:你能不将整数转为字符串来解决这个问题吗？

解法1 字符反转
        # 自己写的 转换字符
        s = str(x)
        x = s[::-1]
        if x == s:
            return True
        else:
            return False
            
解法2 数字反转一半
  	   """
        只反转后面一半的数字!!(节省一半的时间)
        """
        if x < 0 or (x!=0 and x%10==0):
            return False
        elif x == 0:
            return True
        else:
            reverse_x = 0
            while x > reverse_x:
                remainder = x % 10
                reverse_x = reverse_x * 10 + remainder
                x = x // 10
            # 当x为奇数时, 只要满足 reverse_x//10 == x 即可
            if reverse_x == x or reverse_x//10 == x:
                return True
            else:
                return False