leecode第7天

69、x的平方根

# 给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
# 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
# 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

class Solution(object):
    def mySqrt(self, x):
        """
        使用二分查找法计算非负整数x的平方根整数部分
        
        :type x: int
        :param x: 需要计算平方根的非负整数
        :rtype: int
        :return: 平方根的整数部分，即最大满足n² ≤ x的整数n
        """
        # 处理边界情况：0和1的平方根为自身
        if x==0:
            return 0
        if x==1:
            return 1
    
        # 初始化二分查找区间[0, x]
        a=0
        b=x
        lenth=b-a
        
        # 二分查找核心逻辑：当区间长度大于1时持续收缩
        while lenth>1:
            center=(a+b)/2
            # 中间值的平方不大于x时，移动左边界
            if (center*center)<=x:
                a=center
            # 中间值的平方大于x时，移动右边界
            elif (center*center)>x:
                b=center
            lenth=b-a
            
        # 最终返回左边界整数部分（向下取整）
        return int(a)

flowchart TD
    A[开始] --> B{x是0或1?}
    B -->|是| C[返回对应值]
    B -->|否| D[初始化区间a=0, b=x]
    D --> E{区间长度>1?}
    E -->|是| F[计算中间值center]
    F --> G{center² ≤x?}
    G -->|是| H[移动左边界a=center]
    G -->|否| I[移动右边界b=center]
    H --> J[更新区间长度]
    I --> J
    J --> E
    E -->|否| K[返回a的整数部分]

70、爬楼梯

# 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
# 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
import math

class Solution:
    
    #自己
    def climbStairs(self, n):
        """
        计算爬到第n个台阶的方法数。
        
        每次可以爬1个或2个台阶，使用循环和组合数学方法计算所有可能的爬法。
        
        :param n: 目标台阶数
        :return: 爬到第n个台阶的方法数
        """
        # 初始化爬楼梯的方法计数器
        way = 0
        # 遍历每一步爬1个台阶和爬2个台阶的组合
        for i in range(n + 1):
            # 当剩余的台阶数可以被2整除时，表示存在爬2个台阶的组合
            if (n - i) % 2 == 0:
                n2 = int((n - i) / 2)
                # 使用组合公式计算当前组合的方法数
                j = (math.factorial(n2 + i)) / (math.factorial(i) * math.factorial(n2))
                # 打印当前的爬法组合
                print('i', i)
                print(j)
                # 累加当前组合的方法数到总方法数
                way += j
        # 返回总方法数
        return way
    	
    #leecode
    def climbStairs(self, n):
        """
        使用动态规划的方法计算爬到第n个台阶的方法数。

        :param n: 目标台阶的位置
        :type n: int
        :return: 爬到第n个台阶的方法数
        :rtype: int
        """
        # 初始化动态规划数组，前两个值基于问题定义
        dp = [0, 1, 2]
        # 从第三个台阶开始，到第n个台阶结束
        for i in range(3, n + 1):
            # 动态规划的核心递推公式：dp[i] = dp[i-1] + dp[i-2]
            dp.append(dp[i-1] + dp[i - 2])
        # 返回爬到第n个台阶的方法数
        return dp[n]

flowchart TD
    A[开始] --> B[初始化dp数组为0,1,2]
    B --> C{n < 3?}
    C -->|是| D[返回dp【n】]
    C -->|否| E[设置i=3]
    E --> F{i <=n?}
    F -->|是| G[计算dp【i】并添加到数组]
    G --> H[i自增1]
    H --> F
    F -->|否| I[返回dp]

83.删除排序链表中的重复元素

# 给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
        
class Solution(object):
    def deleteDuplicates(self, head):
        """
        删除有序链表中重复的节点，保留单个节点。

        参数:
        head (Optional[ListNode]): 链表的头节点。链表需按升序排列，可能为空。
        
        返回值:
        Optional[ListNode]: 删除重复节点后的新链表的头节点。

        实现说明:
        使用双指针法遍历链表，跳过连续重复的节点。
        """
        if head is None: return head

        # 创建虚拟头节点，简化头节点被删除时的处理
        dummy=ListNode()
        dummy.next=head

        cur=head
        pre=head.next
        # 遍历链表，cur指向当前最后一个不重复节点，pre用于探测后续节点
        while pre is not None:
            if cur.val==pre.val:
                # 发现重复，跳过pre节点
                pre=pre.next
                cur.next=pre
            elif cur.val!=pre.val:
                # 无重复，移动cur到pre位置
                cur=pre
                pre=pre.next
        
        return dummy.next

100、相同的树

# 给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

# 如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

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

    def isSameTree(self, p, q):
        """
        判断两棵二叉树是否相同。
        
        参数:
        :type p: Optional[TreeNode] - 二叉树的根节点
        :type q: Optional[TreeNode] - 二叉树的根节点
        
        返回值:
        :rtype: bool - 如果两棵树相同返回True，否则返回False
        """
        # 如果两棵树都为空，则认为它们相同
        if not p and not q: 
            return True
        # 如果其中一棵树为空，而另一棵不为空，则认为它们不相同
        elif not p or not q: 
            return False
        # 如果两棵树的根节点值不相同，则认为它们不相同
        elif p.val != q.val: 
            return False
        # 递归比较两棵树的左子树和右子树
        return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)