发表于 | 分类于

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

请找出其中最小的元素。

你可以假设数组中不存在重复元素。

示例 1:

输入: [3,4,5,1,2]
输出: 1

示例 2:

输入: [4,5,6,7,0,1,2]
输出: 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution(object):
    def findMin(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l,r=0,len(nums)-1
        while l<r:
            mid = (l+r)//2
            if nums[mid] < nums[r]:
                r = mid
            else:
                l = mid + 1
        return nums[l]

发表于 | 分类于

给定一个整数数组 nums ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。

示例 1:

输入: [2,3,-2,4]
输出: 6
解释: 子数组 [2,3] 有最大乘积 6。

示例 2:

输入: [-2,0,-1]
输出: 0
解释: 结果不能为 2, 因为 [-2,-1] 不是子数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution(object):
    def maxProduct(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #dp transfer
        #max_local = max(max(max_local_pre*nums[i],nums[i]),min_local_pre*nums[i])
        #min_local = min(min(max_local_pre*nums[i],nums[i]),min_local_pre*nums[i])
        #max_global = max(max_local,max_global_pre)
        if not nums:return 0
        max_local = nums[0]
        min_local = nums[0]
        max_global = nums[0]
        for i in range(1,len(nums)):
            max_local_pre= max_local
            max_local = max(max(max_local*nums[i],nums[i]),min_local*nums[i])
            min_local = min(min(max_local_pre*nums[i],nums[i]),min_local*nums[i])
            max_global = max(max_local,max_global)
        return max_global

发表于 | 分类于

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：

每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]

给定 target = 5，返回 true。

给定 target = 20，返回 false。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Solution:
    def searchMatrix(self, matrix, target):
        """
        :type matrix: List[List[int]]
        :type target: int
        :rtype: bool
        """
        row = 0
        col = len(matrix[0]) - 1
        while col >= 0 and row < len(matrix):
            if target > matrix[row][col]:
                row += 1
            elif target < matrix[row][col]:
                col -= 1
            else:return True
        return False

发表于 | 分类于

给定长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。

示例:

输入: [1,2,3,4]
输出: [24,12,8,6]
说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。

进阶：
你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的，输出数组不被视为额外空间。）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution:
    def productExceptSelf(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        tmp = 1
        
        n = len(nums)
        res = [1]*n
        for i in range(n):
            res[i] *= tmp
            tmp *= nums[i]
        tmp = 1
        for i in range(n-1,-1,-1):
            res[i] *= tmp
            tmp *= nums[i]
        return res

发表于 | 分类于

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

  
        _______3______
       /              \
    ___5__          ___1__
   /      \        /      \
   6      _2       0       8
         /  \
         7   4

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。

示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

说明:

  • 所有节点的值都是唯一的。
  • p、q 为不同节点且均存在于给定的二叉树中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def lowestCommonAncestor(self, root, p, q):
        """
        :type root: TreeNode
        :type p: TreeNode
        :type q: TreeNode
        :rtype: TreeNode
        """
        if not root:return None
        if root == p or root == q:return root
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)
        if left and right:return root
        return left if left else right

发表于 | 分类于

给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。

示例:


输入: 13
输出: 6
解释: 数字 1 出现在以下数字中: 1, 10, 11, 12, 13 。

思路：

  • 假设n=abcde，如果要计算百位上的1的次数，受到3个因素的影响：百位上的数字，百位下的数字，百位上的数字。
  • 如果百位上的数字是0，百位上可能出现的1的次数由更高位决定，等于(ab)*100
  • 如果百位上数字是1，百位上可能出现的1的次数由更高位和低位决定，等于(ab)*100+(cde)+1
  • 如果百位上数字是其他，百位上可能出现的1的次数由更高位决定，等于(ab+1)*100.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution:
    def countDigitOne(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n <= 0:return 0
        factor = 1
        count = 0
        while n//factor != 0:
            lower = n - n//factor*factor
            cur = n//factor%10
            higher = n//(factor*10)
            if cur == 0:
                count += higher*factor
            elif cur == 1:
                count += higher*factor + lower + 1
            else:
                count += (higher+1)*factor
            factor *= 10
        return count

发表于 | 分类于

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。

说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
输出: 1

示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 3

进阶：

  • 如果二叉搜索树经常被修改（插入/删除操作）并且你需要频繁地查找第 k 小的值，你将如何优化 kthSmallest 函数？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        res = []
        def dfs(root):
            if not root:return
            res.append(root.val)
            dfs(root.left)
            dfs(root.right)
        dfs(root)
        res.sort()
        return res[k-1]

发表于 | 分类于

给定一个大小为 n 的数组，找出其中所有出现超过 ⌊ n/3 ⌋ 次的元素。

说明: 要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

示例 1:

输入: [3,2,3]
输出: [3]

示例 2:

输入: [1,1,1,3,3,2,2,2]
输出: [1,2]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution:
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        if not nums:return []
        d = {}
        n = len(nums)
        res = []
        for i in nums:
            if i in d:
                d[i] += 1
            else:
                d[i] = 1
        
        for key in d:
            if d[key]>n/3:
                res.append(key)
        return res

发表于 | 分类于

给定一个无重复元素的有序整数数组，返回数组区间范围的汇总。

示例 1:

输入: [0,1,2,4,5,7]
输出: ["0->2","4->5","7"]
解释: 0,1,2 可组成一个连续的区间; 4,5 可组成一个连续的区间。

示例 2:

输入: [0,2,3,4,6,8,9]
输出: ["0","2->4","6","8->9"]
解释: 2,3,4 可组成一个连续的区间; 8,9 可组成一个连续的区间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class Solution:
    def summaryRanges(self, nums):
        """
        :type nums: List[int]
        :rtype: List[str]
        """
        if not nums:
            return []
        nums = nums + [nums[-1]]
        num1 = str(nums[0])
        num2=str(nums[0])
        res = []
        for i in range(1,len(nums)):
            if nums[i] - nums[i-1] == 1:
                num2 = str(nums[i])
                continue
            else:
                if num1 == num2:
                    res.append(num1)
                else:
                    res.append(num1+'->'+num2)
                num1 = str(nums[i])
                num2 = str(nums[i])
        return res

发表于 | 分类于

实现一个基本的计算器来计算一个简单的字符串表达式的值。

字符串表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格 。 整数除法仅保留整数部分。

示例 1:

输入: "3+2*2"
输出: 7

示例 2:

输入: " 3/2 "
输出: 1

示例 3:

输入: " 3+5 / 2 "
输出: 5

说明：

  • 你可以假设所给定的表达式都是有效的。
  • 请不要使用内置的库函数 eval。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import re
import math
class Solution:
    def calculate(self, s):
        """
        :type s: str
        :rtype: int
        """
        s = s.replace(' ','')
        ops = [c for c in s if not c.isdigit()]
        numstr = re.split('[+-/*]',s)
        nums = [int(num) for num in numstr]
        stack = []
        stack.append(nums[0])
        i = 1
        j = 0
        while i < len(nums) and j < len(ops):
            stack.append(nums[i])
            if ops[j] == '-':
                num1 = stack.pop()
                stack.append(-num1)
            if ops[j] == '*':
                num1 = stack.pop()
                num2 = stack.pop()
                stack.append(num2*num1)
            if ops[j] == '/':
                num1 = stack.pop()
                num2 = stack.pop()
                t1 = num2/num1
                t2 = math.floor(t1) if t1 > 0 else math.ceil(t1)
                stack.append(t2)
            i += 1
            j += 1
        return sum(stack)

还有一个方法，使用正则来解决，但是消耗的时间更大