LeetCode热题(四)

二叉树的直径

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。

链接：https://leetcode-cn.com/problems/diameter-of-binary-tree/

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

class Solution:
    def __init__(self):
        self.max = 0
    
    def getDepth(self, node):
        if not node:
            return 0
        
        left = self.getDepth(node.left)
        right = self.getDepth(node.right)
        self.max = max(self.max, left + right)
        
        return max(left, right) + 1
    
    def diameterOfBinaryTree(self, root: TreeNode) -> int:
        self.getDepth(root)   
        return self.max

爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

链接：https://leetcode-cn.com/problems/climbing-stairs/

class Solution:
    def climbStairs(self, n: int) -> int:
        a,b=1,1
        for _ in range(n):
            a,b=b,a+b
        return a

环形链表

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

链接：https://leetcode-cn.com/problems/linked-list-cycle

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

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        a=head
        if a==None:
            return False
        b=head.next
        while b!=None and b.next!=None:
            if a==b:
                return True
            else:
                a=a.next
                b=b.next.next
        return False

两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

链接：https://leetcode-cn.com/problems/two-sum

class Solution:
    def bin_search(self, li, left, right, val):
        while left <= right:
            mid=(left + right) // 2
            if li[mid][1] == val:
                return mid
            elif li[mid][1] > val:
                right = mid - 1
            else:
                left = mid + 1
        return None

    def twoSum(self, nums: List[int], target: int) -> List[int]:
        num = [[x,y] for x,y in enumerate(nums)]
        num.sort(key = lambda x:x[1])
        for i in range(len(nums)):
            a = num[i][1]
            b = target - a
            if b > a:
                j = self.bin_search(num, i+1, len(num)-1, b)
            else:
                j = self.bin_search(num, 0, i-1, b)
            if j != None:
                return sorted([num[i][0], num[j][0]])

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

链接：https://leetcode-cn.com/problems/house-robber

class Solution:
    def rob(self, nums: List[int]) -> int:
        if len(nums)==0:
            return 0
        elif len(nums)==1:
            return nums[0]
        else:
            nums[1]=max(nums[0],nums[1])
        
            for i in range(2,len(nums)):
                nums[i]=max(nums[i]+nums[i-2],nums[i-1])

            return nums[-1]