Skip to content
大纲

高频面试题

高频题

[001] 3.无重复字符的最长子串

给定一个字符串 s ,请你找出其中不含有重复字符的 最长子串 的长度。

 

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。

示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke",所以其长度为 3。
     请注意,你的答案必须是 子串 的长度,"pwke" 是一个子序列,不是子串。

示例 4:

输入: s = ""
输出: 0

 

提示:

  • 0 <= s.length <= 5 * 104
  • s 由英文字母、数字、符号和空格组成

[002] 206.反转链表

给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。

 

示例 1:

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

示例 2:

输入:head = [1,2]
输出:[2,1]

示例 3:

输入:head = []
输出:[]

 

提示:

  • 链表中节点的数目范围是 [0, 5000]
  • -5000 <= Node.val <= 5000

 

进阶:链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题?

[003] 146.LRU缓存机制

运用你所掌握的数据结构,设计和实现一个  LRU (最近最少使用) 缓存机制

实现 LRUCache 类:

  • LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
  • int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1
  • void put(int key, int value) 如果关键字已经存在,则变更其数据值;如果关键字不存在,则插入该组「关键字-值」。当缓存容量达到上限时,它应该在写入新数据之前删除最久未使用的数据值,从而为新的数据值留出空间。

 

进阶:你是否可以在 O(1) 时间复杂度内完成这两种操作?

 

示例:

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废,缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废,缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

 

提示:

  • 1 <= capacity <= 3000
  • 0 <= key <= 10000
  • 0 <= value <= 105
  • 最多调用 2 * 105getput

[004] 215.数组中的第K个最大元素

给定整数数组 nums 和整数 k,请返回数组中第 k 个最大的元素。

请注意,你需要找的是数组排序后的第 k 个最大的元素,而不是第 k 个不同的元素。

 

示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例 2:

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

 

提示:

  • 1 <= k <= nums.length <= 104
  • -104 <= nums[i] <= 104

[005] 25.K 个一组翻转链表

给你一个链表,每 个节点一组进行翻转,请你返回翻转后的链表。

是一个正整数,它的值小于或等于链表的长度。

如果节点总数不是 的整数倍,那么请将最后剩余的节点保持原有顺序。

进阶:

  • 你可以设计一个只使用常数额外空间的算法来解决此问题吗?
  • 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

 

示例 1:

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

示例 2:

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

示例 3:

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

示例 4:

输入:head = [1], k = 1
输出:[1]

提示:

  • 列表中节点的数量在范围 sz
  • 1 <= sz <= 5000
  • 0 <= Node.val <= 1000
  • 1 <= k <= sz

[006] 15.三数之和

给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有和为 0 且不重复的三元组。

注意:答案中不可以包含重复的三元组。

 

示例 1:

输入:nums = [-1,0,1,2,-1,-4]
输出:[[-1,-1,2],[-1,0,1]]

示例 2:

输入:nums = []
输出:[]

示例 3:

输入:nums = [0]
输出:[]

 

提示:

  • 0 <= nums.length <= 3000
  • -105 <= nums[i] <= 105

[007] 53.最大子序和

给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。

 

示例 1:

输入:nums = [-2,1,-3,4,-1,2,1,-5,4]
输出:6
解释:连续子数组 [4,-1,2,1] 的和最大,为 6 。

示例 2:

输入:nums = [1]
输出:1

示例 3:

输入:nums = [0]
输出:0

示例 4:

输入:nums = [-1]
输出:-1

示例 5:

输入:nums = [-100000]
输出:-100000

 

提示:

  • 1 <= nums.length <= 3 * 104
  • -105 <= nums[i] <= 105

 

进阶:如果你已经实现复杂度为 O(n) 的解法,尝试使用更为精妙的 分治法 求解。

[008] 补充题4.手撕快速排序

给你一个整数数组 nums,请你将该数组升序排列。

 

    示例 1:

    输入:nums = [5,2,3,1]输出:[1,2,3,5]

    示例 2:

    输入:nums = [5,1,1,2,0,0]输出:[0,0,1,1,2,5]

     

    提示:

    1. 1 <= nums.length <= 50000
    2. -50000 <= nums[i] <= 50000

    [009] 21.合并两个有序链表

    将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

     

    示例 1:

    输入:l1 = [1,2,4], l2 = [1,3,4]
    输出:[1,1,2,3,4,4]
    

    示例 2:

    输入:l1 = [], l2 = []
    输出:[]
    

    示例 3:

    输入:l1 = [], l2 = [0]
    输出:[0]
    

     

    提示:

    • 两个链表的节点数目范围是 [0, 50]
    • -100 <= Node.val <= 100
    • l1l2 均按 非递减顺序 排列

    [010] 1.两数之和

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

    你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。

    你可以按任意顺序返回答案。

     

    示例 1:

    输入:nums = [2,7,11,15], target = 9
    输出:[0,1]
    解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
    

    示例 2:

    输入:nums = [3,2,4], target = 6
    输出:[1,2]
    

    示例 3:

    输入:nums = [3,3], target = 6
    输出:[0,1]
    

     

    提示:

    • 2 <= nums.length <= 104
    • -109 <= nums[i] <= 109
    • -109 <= target <= 109
    • 只会存在一个有效答案

    进阶:你可以想出一个时间复杂度小于 O(n2) 的算法吗?

    [011] 102.二叉树的层序遍历

    给你一个二叉树,请你返回其按 层序遍历 得到的节点值。 (即逐层地,从左到右访问所有节点)。

     

    示例:
    二叉树:[3,9,20,null,null,15,7],

        3
       / \
      9  20
        /  \
       15   7
    

    返回其层序遍历结果:

    [
      [3],
      [9,20],
      [15,7]
    ]
    

    [012] 5.最长回文子串

    给你一个字符串 s,找到 s 中最长的回文子串。

     

    示例 1:

    输入:s = "babad"
    输出:"bab"
    解释:"aba" 同样是符合题意的答案。
    

    示例 2:

    输入:s = "cbbd"
    输出:"bb"
    

    示例 3:

    输入:s = "a"
    输出:"a"
    

    示例 4:

    输入:s = "ac"
    输出:"a"
    

     

    提示:

    • 1 <= s.length <= 1000
    • s 仅由数字和英文字母(大写和/或小写)组成

    [013] 33.搜索旋转排序数组

    整数数组 nums 按升序排列,数组中的值 互不相同

    在传递给函数之前,nums 在预先未知的某个下标 k0 <= k < nums.length)上进行了 旋转,使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]](下标 从 0 开始 计数)。例如, [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2]

    给你 旋转后 的数组 nums 和一个整数 target ,如果 nums 中存在这个目标值 target ,则返回它的下标,否则返回 -1 。

     

    示例 1:

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

    示例 2:

    输入:nums = [4,5,6,7,0,1,2], target = 3
    输出:-1

    示例 3:

    输入:nums = [1], target = 0
    输出:-1
    

     

    提示:

    • 1 <= nums.length <= 5000
    • -10^4 <= nums[i] <= 10^4
    • nums 中的每个值都 独一无二
    • 题目数据保证 nums 在预先未知的某个下标上进行了旋转
    • -10^4 <= target <= 10^4

     

    进阶:你可以设计一个时间复杂度为 O(log n) 的解决方案吗?

    [014] 20.有效的括号

    给定一个只包括 '('')''{''}''['']' 的字符串 s ,判断字符串是否有效。

    有效字符串需满足:

    1. 左括号必须用相同类型的右括号闭合。
    2. 左括号必须以正确的顺序闭合。

     

    示例 1:

    输入:s = "()"
    输出:true
    

    示例 2:

    输入:s = "()[]{}"
    输出:true
    

    示例 3:

    输入:s = "(]"
    输出:false
    

    示例 4:

    输入:s = "([)]"
    输出:false
    

    示例 5:

    输入:s = "{[]}"
    输出:true

     

    提示:

    • 1 <= s.length <= 104
    • s 仅由括号 '()[]{}' 组成

    [015] 141.环形链表

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

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

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

     

    进阶:

    你能用 O(1)(即,常量)内存解决此问题吗?

     

    示例 1:

    输入:head = [3,2,0,-4], pos = 1
    输出:true
    解释:链表中有一个环,其尾部连接到第二个节点。
    

    示例 2:

    输入:head = [1,2], pos = 0
    输出:true
    解释:链表中有一个环,其尾部连接到第一个节点。
    

    示例 3:

    输入:head = [1], pos = -1
    输出:false
    解释:链表中没有环。
    

     

    提示:

    • 链表中节点的数目范围是 [0, 104]
    • -105 <= Node.val <= 105
    • pos-1 或者链表中的一个 有效索引

    [016] 121.买卖股票的最佳时机

    给定一个数组 prices ,它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

    你只能选择 某一天 买入这只股票,并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

    返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润,返回 0

     

    示例 1:

    输入:[7,1,5,3,6,4]
    输出:5
    解释:在第 2 天(股票价格 = 1)的时候买入,在第 5 天(股票价格 = 6)的时候卖出,最大利润 = 6-1 = 5 。
         注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格;同时,你不能在买入前卖出股票。
    

    示例 2:

    输入:prices = [7,6,4,3,1]
    输出:0
    解释:在这种情况下, 没有交易完成, 所以最大利润为 0。
    

     

    提示:

    • 1 <= prices.length <= 105
    • 0 <= prices[i] <= 104

    [017] 88.合并两个有序数组

    给你两个按 非递减顺序 排列的整数数组 nums1 nums2,另有两个整数 mn ,分别表示 nums1nums2 中的元素数目。

    请你 合并 nums2 nums1 中,使合并后的数组同样按 非递减顺序 排列。

    注意:最终,合并后数组不应由函数返回,而是存储在数组 nums1 中。为了应对这种情况,nums1 的初始长度为 m + n,其中前 m 个元素表示应合并的元素,后 n 个元素为 0 ,应忽略。nums2 的长度为 n

     

    示例 1:

    输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
    输出:[1,2,2,3,5,6]
    解释:需要合并 [1,2,3] 和 [2,5,6] 。
    合并结果是 [1,2,2,3,5,6] ,其中斜体加粗标注的为 nums1 中的元素。
    

    示例 2:

    输入:nums1 = [1], m = 1, nums2 = [], n = 0
    输出:[1]
    解释:需要合并 [1] 和 [] 。
    合并结果是 [1] 。
    

    示例 3:

    输入:nums1 = [0], m = 0, nums2 = [1], n = 1
    输出:[1]
    解释:需要合并的数组是 [] 和 [1] 。
    合并结果是 [1] 。
    注意,因为 m = 0 ,所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
    

     

    提示:

    • nums1.length == m + n
    • nums2.length == n
    • 0 <= m, n <= 200
    • 1 <= m + n <= 200
    • -109 <= nums1[i], nums2[j] <= 109

     

    进阶:你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗?

    [018] 200.岛屿数量

    给你一个由 '1'(陆地)和 '0'(水)组成的的二维网格,请你计算网格中岛屿的数量。

    岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。

    此外,你可以假设该网格的四条边均被水包围。

     

    示例 1:

    输入:grid = [
      ["1","1","1","1","0"],
      ["1","1","0","1","0"],
      ["1","1","0","0","0"],
      ["0","0","0","0","0"]
    ]
    输出:1
    

    示例 2:

    输入:grid = [
      ["1","1","0","0","0"],
      ["1","1","0","0","0"],
      ["0","0","1","0","0"],
      ["0","0","0","1","1"]
    ]
    输出:3
    

     

    提示:

    • m == grid.length
    • n == grid[i].length
    • 1 <= m, n <= 300
    • grid[i][j] 的值为 '0''1'

    [019] 103.二叉树的锯齿形层次遍历

    给定一个二叉树,返回其节点值的锯齿形层序遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。

    例如:
    给定二叉树 [3,9,20,null,null,15,7],

        3
       / \
      9  20
        /  \
       15   7
    

    返回锯齿形层序遍历如下:

    [
      [3],
      [20,9],
      [15,7]
    ]
    

    [020] 46.全排列

    给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。

     

    示例 1:

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

    示例 2:

    输入:nums = [0,1]
    输出:[[0,1],[1,0]]
    

    示例 3:

    输入:nums = [1]
    输出:[[1]]
    

     

    提示:

    • 1 <= nums.length <= 6
    • -10 <= nums[i] <= 10
    • nums 中的所有整数 互不相同

    [021] 236.二叉树的最近公共祖先

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

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

    示例 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 。因为根据定义最近公共祖先节点可以为节点本身。
    

    示例 3:

    输入:root = [1,2], p = 1, q = 2
    输出:1
    

    提示:

    • 树中节点数目在范围 [2, 105] 内。
    • -109 <= Node.val <= 109
    • 所有 Node.val 互不相同
    • p != q
    • pq 均存在于给定的二叉树中。

    [022] 54.螺旋矩阵

    给你一个 mn 列的矩阵 matrix ,请按照 顺时针螺旋顺序 ,返回矩阵中的所有元素。

    示例 1:

    输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]
    输出:[1,2,3,6,9,8,7,4,5]
    

    示例 2:

    输入:matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
    输出:[1,2,3,4,8,12,11,10,9,5,6,7]
    

    提示:

    • m == matrix.length
    • n == matrix[i].length
    • 1 <= m, n <= 10
    • -100 <= matrix[i][j] <= 100

    [023] 160.相交链表

    给你两个单链表的头节点 headAheadB ,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null

    图示两个链表在节点 c1 开始相交

    题目数据 保证 整个链式结构中不存在环。

    注意,函数返回结果后,链表必须 保持其原始结构

    示例 1:

    输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
    输出:Intersected at '8'
    解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
    从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。
    在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
    

    示例 2:

    输入:intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
    输出:Intersected at '2'
    解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。
    从各自的表头开始算起,链表 A 为 [0,9,1,2,4],链表 B 为 [3,2,4]。
    在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。
    

    示例 3:

    输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
    输出:null
    解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。
    由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
    这两个链表不相交,因此返回 null 。
    

    提示:

    • listA 中节点数目为 m
    • listB 中节点数目为 n
    • 0 <= m, n <= 3 * 104
    • 1 <= Node.val <= 105
    • 0 <= skipA <= m
    • 0 <= skipB <= n
    • 如果 listAlistB 没有交点,intersectVal0
    • 如果 listAlistB 有交点,intersectVal == listA[skipA + 1] == listB[skipB + 1]

    进阶:你能否设计一个时间复杂度 O(n) 、仅用 O(1) 内存的解决方案?

    [024] 92.反转链表 II

    给你单链表的头指针 head 和两个整数 leftright ,其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点,返回 反转后的链表

    示例 1:

    输入:head = [1,2,3,4,5], left = 2, right = 4
    输出:[1,4,3,2,5]
    

    示例 2:

    输入:head = [5], left = 1, right = 1
    输出:[5]
    

    提示:

    • 链表中节点数目为 n
    • 1 <= n <= 500
    • -500 <= Node.val <= 500
    • 1 <= left <= right <= n

    进阶: 你可以使用一趟扫描完成反转吗?

    [025] 23.合并K个排序链表

    给你一个链表数组,每个链表都已经按升序排列。

    请你将所有链表合并到一个升序链表中,返回合并后的链表。

     

    示例 1:

    输入:lists = [[1,4,5],[1,3,4],[2,6]]
    输出:[1,1,2,3,4,4,5,6]
    解释:链表数组如下:
    [
      1->4->5,
      1->3->4,
      2->6
    ]
    将它们合并到一个有序链表中得到。
    1->1->2->3->4->4->5->6
    

    示例 2:

    输入:lists = []
    输出:[]
    

    示例 3:

    输入:lists = [[]]
    输出:[]
    

     

    提示:

    • k == lists.length
    • 0 <= k <= 10^4
    • 0 <= lists[i].length <= 500
    • -10^4 <= lists[i][j] <= 10^4
    • lists[i]升序 排列
    • lists[i].length 的总和不超过 10^4

    [026] 415.字符串相加

    给定两个字符串形式的非负整数 num1num2 ,计算它们的和并同样以字符串形式返回。

    你不能使用任何內建的用于处理大整数的库(比如 BigInteger), 也不能直接将输入的字符串转换为整数形式。

     

    示例 1:

    输入:num1 = "11", num2 = "123"
    输出:"134"
    

    示例 2:

    输入:num1 = "456", num2 = "77"
    输出:"533"
    

    示例 3:

    输入:num1 = "0", num2 = "0"
    输出:"0"
    

     

     

    提示:

    • 1 <= num1.length, num2.length <= 104
    • num1num2 都只包含数字 0-9
    • num1num2 都不包含任何前导零

    [027] 300.最长上升子序列

    给你一个整数数组 nums ,找到其中最长严格递增子序列的长度。

    子序列是由数组派生而来的序列,删除(或不删除)数组中的元素而不改变其余元素的顺序。例如,[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

    示例 1:

    输入:nums = [10,9,2,5,3,7,101,18]
    输出:4
    解释:最长递增子序列是 [2,3,7,101],因此长度为 4 。
    

    示例 2:

    输入:nums = [0,1,0,3,2,3]
    输出:4
    

    示例 3:

    输入:nums = [7,7,7,7,7,7,7]
    输出:1
    

    提示:

    • 1 <= nums.length <= 2500
    • -104 <= nums[i] <= 104

    进阶:

    • 你可以设计时间复杂度为 O(n2) 的解决方案吗?
    • 你能将算法的时间复杂度降低到 O(n log(n)) 吗?

    [028] 142.环形链表 II

    给定一个链表,返回链表开始入环的第一个节点。 如果链表无环,则返回 null

    为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos-1,则在该链表中没有环。注意,pos 仅仅是用于标识环的情况,并不会作为参数传递到函数中。

    说明:不允许修改给定的链表。

    进阶:

    • 你是否可以使用 O(1) 空间解决此题?

    示例 1:

    输入:head = [3,2,0,-4], pos = 1
    输出:返回索引为 1 的链表节点
    解释:链表中有一个环,其尾部连接到第二个节点。
    

    示例 2:

    输入:head = [1,2], pos = 0
    输出:返回索引为 0 的链表节点
    解释:链表中有一个环,其尾部连接到第一个节点。
    

    示例 3:

    输入:head = [1], pos = -1
    输出:返回 null
    解释:链表中没有环。
    

    提示:

    • 链表中节点的数目范围在范围 [0, 104]
    • -105 <= Node.val <= 105
    • pos 的值为 -1 或者链表中的一个有效索引

    [029] 42.接雨水

    给定 n 个非负整数表示每个宽度为 1 的柱子的高度图,计算按此排列的柱子,下雨之后能接多少雨水。

    示例 1:

    输入:height = [0,1,0,2,1,0,1,3,2,1,2,1]
    输出:6
    解释:上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图,在这种情况下,可以接 6 个单位的雨水(蓝色部分表示雨水)。 
    

    示例 2:

    输入:height = [4,2,0,3,2,5]
    输出:9
    

    提示:

    • n == height.length
    • 0 <= n <= 3 * 104
    • 0 <= height[i] <= 105

    [030] 143.重排链表

    给定一个单链表 L 的头节点 head ,单链表 L 表示为:

    L0 → L1 → … → Ln-1 → Ln
    请将其重新排列后变为:

    L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

    不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。

    示例 1:

    输入: head = [1,2,3,4]
    输出: [1,4,2,3]

    示例 2:

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

    提示:

    • 链表的长度范围为 [1, 5 * 104]
    • 1 <= node.val <= 1000

    [031] 124.二叉树中的最大路径和

    路径 被定义为一条从树中任意节点出发,沿父节点-子节点连接,达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点,且不一定经过根节点。

    路径和 是路径中各节点值的总和。

    给你一个二叉树的根节点 root ,返回其 最大路径和

    示例 1:

    输入:root = [1,2,3]
    输出:6
    解释:最优路径是 2 -> 1 -> 3 ,路径和为 2 + 1 + 3 = 6

    示例 2:

    输入:root = [-10,9,20,null,null,15,7]
    输出:42
    解释:最优路径是 15 -> 20 -> 7 ,路径和为 15 + 20 + 7 = 42
    

    提示:

    • 树中节点数目范围是 [1, 3 * 104]
    • -1000 <= Node.val <= 1000

    [032] 94.二叉树的中序遍历

    给定一个二叉树的根节点 root ,返回它的 中序 遍历。

    示例 1:

    输入:root = [1,null,2,3]
    输出:[1,3,2]
    

    示例 2:

    输入:root = []
    输出:[]
    

    示例 3:

    输入:root = [1]
    输出:[1]
    

    示例 4:

    输入:root = [1,2]
    输出:[2,1]
    

    示例 5:

    输入:root = [1,null,2]
    输出:[1,2]
    

    提示:

    • 树中节点数目在范围 [0, 100]
    • -100 <= Node.val <= 100

    进阶: 递归算法很简单,你可以通过迭代算法完成吗?

    [033] 19.删除链表的倒数第N个节点

    给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。

    进阶:你能尝试使用一趟扫描实现吗?

    示例 1:

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

    示例 2:

    输入:head = [1], n = 1
    输出:[]
    

    示例 3:

    输入:head = [1,2], n = 1
    输出:[1]
    

    提示:

    • 链表中结点的数目为 sz
    • 1 <= sz <= 30
    • 0 <= Node.val <= 100
    • 1 <= n <= sz

    [034] 232.用栈实现队列

    请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(pushpoppeekempty):

    实现 MyQueue 类:

    • void push(int x) 将元素 x 推到队列的末尾
    • int pop() 从队列的开头移除并返回元素
    • int peek() 返回队列开头的元素
    • boolean empty() 如果队列为空,返回 true ;否则,返回 false

    说明:

    • 你只能使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
    • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque(双端队列)来模拟一个栈,只要是标准的栈操作即可。

    进阶:

    • 你能否实现每个操作均摊时间复杂度为 O(1) 的队列?换句话说,执行 n 个操作的总时间复杂度为 O(n) ,即使其中一个操作可能花费较长时间。

    示例:

    输入:
    ["MyQueue", "push", "push", "peek", "pop", "empty"]
    [[], [1], [2], [], [], []]
    输出:
    [null, null, null, 1, 1, false]
    
    解释:
    MyQueue myQueue = new MyQueue();
    myQueue.push(1); // queue is: [1]
    myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
    myQueue.peek(); // return 1
    myQueue.pop(); // return 1, queue is [2]
    myQueue.empty(); // return false
    

    提示:

    • 1 <= x <= 9
    • 最多调用 100pushpoppeekempty
    • 假设所有操作都是有效的 (例如,一个空的队列不会调用 pop 或者 peek 操作)

    [035] 72.编辑距离

    给你两个单词 word1word2,请你计算出将 word1 转换成 word2 所使用的最少操作数 。

    你可以对一个单词进行如下三种操作:

    • 插入一个字符
    • 删除一个字符
    • 替换一个字符

    示例 1:

    输入:word1 = "horse", word2 = "ros"
    输出:3
    解释:
    horse -> rorse (将 'h' 替换为 'r')
    rorse -> rose (删除 'r')
    rose -> ros (删除 'e')
    

    示例 2:

    输入:word1 = "intention", word2 = "execution"
    输出:5
    解释:
    intention -> inention (删除 't')
    inention -> enention (将 'i' 替换为 'e')
    enention -> exention (将 'n' 替换为 'x')
    exention -> exection (将 'n' 替换为 'c')
    exection -> execution (插入 'u')
    

    提示:

    • 0 <= word1.length, word2.length <= 500
    • word1word2 由小写英文字母组成

    [036] 704.二分查找

    给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target  ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1


    示例 1:

    输入: nums = [-1,0,3,5,9,12], target = 9
    输出: 4
    解释: 9 出现在 nums 中并且下标为 4
    

    示例 2:

    输入: nums = [-1,0,3,5,9,12], target = 2
    输出: -1
    解释: 2 不存在 nums 中因此返回 -1
    

     

    提示:

    1. 你可以假设 nums 中的所有元素是不重复的。
    2. n 将在 [1, 10000]之间。
    3. nums 的每个元素都将在 [-9999, 9999]之间。

    [037] 4.寻找两个正序数组的中位数

    给定两个大小分别为 mn 的正序(从小到大)数组 nums1nums2。请你找出并返回这两个正序数组的 中位数

    示例 1:

    输入:nums1 = [1,3], nums2 = [2]
    输出:2.00000
    解释:合并数组 = [1,2,3] ,中位数 2
    

    示例 2:

    输入:nums1 = [1,2], nums2 = [3,4]
    输出:2.50000
    解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5
    

    示例 3:

    输入:nums1 = [0,0], nums2 = [0,0]
    输出:0.00000
    

    示例 4:

    输入:nums1 = [], nums2 = [1]
    输出:1.00000
    

    示例 5:

    输入:nums1 = [2], nums2 = []
    输出:2.00000
    

    提示:

    • nums1.length == m
    • nums2.length == n
    • 0 <= m <= 1000
    • 0 <= n <= 1000
    • 1 <= m + n <= 2000
    • -106 <= nums1[i], nums2[i] <= 106

    进阶:你能设计一个时间复杂度为 O(log (m+n)) 的算法解决此问题吗?

    [038] 1143.最长公共子序列

    给定两个字符串 text1text2,返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ,返回 0

    一个字符串的 子序列 是指这样一个新的字符串:它是由原字符串在不改变字符的相对顺序的情况下删除某些字符(也可以不删除任何字符)后组成的新字符串。

    • 例如,"ace""abcde" 的子序列,但 "aec" 不是 "abcde" 的子序列。

    两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

    示例 1:

    输入:text1 = "abcde", text2 = "ace" 
    输出:3  
    解释:最长公共子序列是 "ace" ,它的长度为 3 。
    

    示例 2:

    输入:text1 = "abc", text2 = "abc"
    输出:3
    解释:最长公共子序列是 "abc" ,它的长度为 3 。
    

    示例 3:

    输入:text1 = "abc", text2 = "def"
    输出:0
    解释:两个字符串没有公共子序列,返回 0 。
    

    提示:

    • 1 <= text1.length, text2.length <= 1000
    • text1text2 仅由小写英文字符组成。

    [039] 56.合并区间

    以数组 intervals 表示若干个区间的集合,其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间,并返回一个不重叠的区间数组,该数组需恰好覆盖输入中的所有区间。

    示例 1:

    输入:intervals = [[1,3],[2,6],[8,10],[15,18]]
    输出:[[1,6],[8,10],[15,18]]
    解释:区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
    

    示例 2:

    输入:intervals = [[1,4],[4,5]]
    输出:[[1,5]]
    解释:区间 [1,4] 和 [4,5] 可被视为重叠区间。

    提示:

    • 1 <= intervals.length <= 104
    • intervals[i].length == 2
    • 0 <= starti <= endi <= 104

    [040] 199.二叉树的右视图

    给定一个二叉树的 根节点 root,想象自己站在它的右侧,按照从顶部到底部的顺序,返回从右侧所能看到的节点值。

    示例 1:

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

    示例 2:

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

    示例 3:

    输入: []
    输出: []
    

    提示:

    • 二叉树的节点个数的范围是 [0,100]
    • -100 <= Node.val <= 100

    [041] 82.删除排序链表中的重复元素 II

    存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除链表中所有存在数字重复情况的节点,只保留原始链表中 没有重复出现 的数字。

    返回同样按升序排列的结果链表。

    示例 1:

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

    示例 2:

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

    提示:

    • 链表中节点数目在范围 [0, 300]
    • -100 <= Node.val <= 100
    • 题目数据保证链表已经按升序排列

    [042] 93.复原IP地址

    给定一个只包含数字的字符串,用以表示一个 IP 地址,返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。

    有效 IP 地址 正好由四个整数(每个整数位于 0 到 255 之间组成,且不能含有前导 0),整数之间用 '.' 分隔。

    例如:"0.1.2.201" 和 "192.168.1.1" 是 有效 IP 地址,但是 "0.011.255.245"、"192.168.1.312" 和 "192.168@1.1" 是 无效 IP 地址。

    示例 1:

    输入:s = "25525511135"
    输出:["255.255.11.135","255.255.111.35"]
    

    示例 2:

    输入:s = "0000"
    输出:["0.0.0.0"]
    

    示例 3:

    输入:s = "1111"
    输出:["1.1.1.1"]
    

    示例 4:

    输入:s = "010010"
    输出:["0.10.0.10","0.100.1.0"]
    

    示例 5:

    输入:s = "101023"
    输出:["1.0.10.23","1.0.102.3","10.1.0.23","10.10.2.3","101.0.2.3"]
    

    提示:

    • 0 <= s.length <= 3000
    • s 仅由数字组成

    [043] 31.下一个排列

    实现获取 下一个排列 的函数,算法需要将给定数字序列重新排列成字典序中下一个更大的排列(即,组合出下一个更大的整数)。

    如果不存在下一个更大的排列,则将数字重新排列成最小的排列(即升序排列)。

    必须 原地 修改,只允许使用额外常数空间。

     

    示例 1:

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

    示例 2:

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

    示例 3:

    输入:nums = [1,1,5]
    输出:[1,5,1]
    

    示例 4:

    输入:nums = [1]
    输出:[1]
    

     

    提示:

    • 1 <= nums.length <= 100
    • 0 <= nums[i] <= 100

    [044] 70.爬楼梯

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

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

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

    示例 1:

    输入: 2
    输出: 2
    解释: 有两种方法可以爬到楼顶。
    1.  1 阶 + 1 阶
    2.  2 阶

    示例 2:

    输入: 3
    输出: 3
    解释: 有三种方法可以爬到楼顶。
    1.  1 阶 + 1 阶 + 1 阶
    2.  1 阶 + 2 阶
    3.  2 阶 + 1 阶
    

    [045] 148.排序链表

    给你链表的头结点 head ,请将其按 升序 排列并返回 排序后的链表

    进阶:

    • 你可以在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序吗?

    示例 1:

    输入:head = [4,2,1,3]
    输出:[1,2,3,4]
    

    示例 2:

    输入:head = [-1,5,3,4,0]
    输出:[-1,0,3,4,5]
    

    示例 3:

    输入:head = []
    输出:[]
    

    提示:

    • 链表中节点的数目在范围 [0, 5 * 104]
    • -105 <= Node.val <= 105

    [046] 2.两数相加

    给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。

    请你将两个数相加,并以相同形式返回一个表示和的链表。

    你可以假设除了数字 0 之外,这两个数都不会以 0 开头。

    示例 1:

    输入:l1 = [2,4,3], l2 = [5,6,4]
    输出:[7,0,8]
    解释:342 + 465 = 807.
    

    示例 2:

    输入:l1 = [0], l2 = [0]
    输出:[0]
    

    示例 3:

    输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
    输出:[8,9,9,9,0,0,0,1]
    

    提示:

    • 每个链表中的节点数在范围 [1, 100]
    • 0 <= Node.val <= 9
    • 题目数据保证列表表示的数字不含前导零

    [047] 22.括号生成

    数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。

    有效括号组合需满足:左括号必须以正确的顺序闭合。

     

    示例 1:

    输入:n = 3
    输出:["((()))","(()())","(())()","()(())","()()()"]
    

    示例 2:

    输入:n = 1
    输出:["()"]
    

     

    提示:

    • 1 <= n <= 8

    [048] 8.字符串转换整数 (atoi)

    请你来实现一个 myAtoi(string s) 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。

    函数 myAtoi(string s) 的算法如下:

    • 读入字符串并丢弃无用的前导空格
    • 检查下一个字符(假设还未到字符末尾)为正还是负号,读取该字符(如果有)。 确定最终结果是负数还是正数。 如果两者都不存在,则假定结果为正。
    • 读入下一个字符,直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
    • 将前面步骤读入的这些数字转换为整数(即,"123" -> 123, "0032" -> 32)。如果没有读入数字,则整数为 0 。必要时更改符号(从步骤 2 开始)。
    • 如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ,需要截断这个整数,使其保持在这个范围内。具体来说,小于 −231 的整数应该被固定为 −231 ,大于 231 − 1 的整数应该被固定为 231 − 1
    • 返回整数作为最终结果。

    注意:

    • 本题中的空白字符只包括空格字符 ' '
    • 除前导空格或数字后的其余字符串外,请勿忽略 任何其他字符。

    示例 1:

    输入:s = "42"
    输出:42
    解释:加粗的字符串为已经读入的字符,插入符号是当前读取的字符。
    第 1 步:"42"(当前没有读入字符,因为没有前导空格)
             ^
    第 2 步:"42"(当前没有读入字符,因为这里不存在 '-' 或者 '+')
             ^
    第 3 步:"42"(读入 "42")
               ^
    解析得到整数 42 。
    由于 "42" 在范围 [-231, 231 - 1] 内,最终结果为 42 。

    示例 2:

    输入:s = "   -42"
    输出:-42
    解释:
    第 1 步:"   -42"(读入前导空格,但忽视掉)
                ^
    第 2 步:"   -42"(读入 '-' 字符,所以结果应该是负数)
                 ^
    第 3 步:"   -42"(读入 "42")
                   ^
    解析得到整数 -42 。
    由于 "-42" 在范围 [-231, 231 - 1] 内,最终结果为 -42 。
    

    示例 3:

    输入:s = "4193 with words"
    输出:4193
    解释:
    第 1 步:"4193 with words"(当前没有读入字符,因为没有前导空格)
             ^
    第 2 步:"4193 with words"(当前没有读入字符,因为这里不存在 '-' 或者 '+')
             ^
    第 3 步:"4193 with words"(读入 "4193";由于下一个字符不是一个数字,所以读入停止)
                 ^
    解析得到整数 4193 。
    由于 "4193" 在范围 [-231, 231 - 1] 内,最终结果为 4193 。
    

    示例 4:

    输入:s = "words and 987"
    输出:0
    解释:
    第 1 步:"words and 987"(当前没有读入字符,因为没有前导空格)
             ^
    第 2 步:"words and 987"(当前没有读入字符,因为这里不存在 '-' 或者 '+')
             ^
    第 3 步:"words and 987"(由于当前字符 'w' 不是一个数字,所以读入停止)
             ^
    解析得到整数 0 ,因为没有读入任何数字。
    由于 0 在范围 [-231, 231 - 1] 内,最终结果为 0 。

    示例 5:

    输入:s = "-91283472332"
    输出:-2147483648
    解释:
    第 1 步:"-91283472332"(当前没有读入字符,因为没有前导空格)
             ^
    第 2 步:"-91283472332"(读入 '-' 字符,所以结果应该是负数)
              ^
    第 3 步:"-91283472332"(读入 "91283472332")
                         ^
    解析得到整数 -91283472332 。
    由于 -91283472332 小于范围 [-231, 231 - 1] 的下界,最终结果被截断为 -231 = -2147483648 。

    提示:

    • 0 <= s.length <= 200
    • s 由英文字母(大写和小写)、数字(0-9)、' ''+''-''.' 组成

    [049] 69.x 的平方根

    给你一个非负整数 x ,计算并返回 x 的 平方根

    由于返回类型是整数,结果只保留 整数部分 ,小数部分将被 舍去 。

    注意:不允许使用任何内置指数函数和算符,例如 pow(x, 0.5) 或者 x ** 0.5

     

    示例 1:

    输入:x = 4
    输出:2
    

    示例 2:

    输入:x = 8
    输出:2
    解释:8 的平方根是 2.82842..., 由于返回类型是整数,小数部分将被舍去。
    

     

    提示:

    • 0 <= x <= 231 - 1

    [050] 239.滑动窗口最大值

    给你一个整数数组 nums,有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

    返回滑动窗口中的最大值。

    示例 1:

    输入:nums = [1,3,-1,-3,5,3,6,7], k = 3
    输出:[3,3,5,5,6,7]
    解释:
    滑动窗口的位置                最大值
    ---------------               -----
    [1  3  -1] -3  5  3  6  7       3
     1 [3  -1  -3] 5  3  6  7       3
     1  3 [-1  -3  5] 3  6  7       5
     1  3  -1 [-3  5  3] 6  7       5
     1  3  -1  -3 [5  3  6] 7       6
     1  3  -1  -3  5 [3  6  7]      7
    

    示例 2:

    输入:nums = [1], k = 1
    输出:[1]
    

    示例 3:

    输入:nums = [1,-1], k = 1
    输出:[1,-1]
    

    示例 4:

    输入:nums = [9,11], k = 2
    输出:[11]
    

    示例 5:

    输入:nums = [4,-2], k = 2
    输出:[4]

    提示:

    • 1 <= nums.length <= 105
    • -104 <= nums[i] <= 104
    • 1 <= k <= nums.length

    [051] 41.缺失的第一个正数

    给你一个未排序的整数数组 nums ,请你找出其中没有出现的最小的正整数。

    请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

    示例 1:

    输入:nums = [1,2,0]
    输出:3
    

    示例 2:

    输入:nums = [3,4,-1,1]
    输出:2
    

    示例 3:

    输入:nums = [7,8,9,11,12]
    输出:1
    

    提示:

    • 1 <= nums.length <= 5 * 105
    • -231 <= nums[i] <= 231 - 1

    [052] 剑指 Offer 22.链表中倒数第k个节点

    输入一个链表,输出该链表中倒数第k个节点。为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点。

    例如,一个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

    示例:

    给定一个链表: 1->2->3->4->5, 和 k = 2.
    
    返回链表 4->5.

    [053] 165.比较版本号

    给你两个版本号 version1version2 ,请你比较它们。

    版本号由一个或多个修订号组成,各修订号由一个 '.' 连接。每个修订号由 多位数字 组成,可能包含 前导零 。每个版本号至少包含一个字符。修订号从左到右编号,下标从 0 开始,最左边的修订号下标为 0 ,下一个修订号下标为 1 ,以此类推。例如,2.5.330.1 都是有效的版本号。

    比较版本号时,请按从左到右的顺序依次比较它们的修订号。比较修订号时,只需比较 忽略任何前导零后的整数值 。也就是说,修订号 1 和修订号 001 相等 。如果版本号没有指定某个下标处的修订号,则该修订号视为 0 。例如,版本 1.0 小于版本 1.1 ,因为它们下标为 0 的修订号相同,而下标为 1 的修订号分别为 010 < 1

    返回规则如下:

    • 如果 version1 > version2 返回 1
    • 如果 version1 < version2 返回 -1
    • 除此之外返回 0

    示例 1:

    输入:version1 = "1.01", version2 = "1.001"
    输出:0
    解释:忽略前导零,"01" 和 "001" 都表示相同的整数 "1"
    

    示例 2:

    输入:version1 = "1.0", version2 = "1.0.0"
    输出:0
    解释:version1 没有指定下标为 2 的修订号,即视为 "0"
    

    示例 3:

    输入:version1 = "0.1", version2 = "1.1"
    输出:-1
    解释:version1 中下标为 0 的修订号是 "0",version2 中下标为 0 的修订号是 "1" 。0 < 1,所以 version1 < version2
    

    示例 4:

    输入:version1 = "1.0.1", version2 = "1"
    输出:1
    

    示例 5:

    输入:version1 = "7.5.2.4", version2 = "7.5.3"
    输出:-1
    

    提示:

    • 1 <= version1.length, version2.length <= 500
    • version1version2 仅包含数字和 '.'
    • version1version2 都是 有效版本号
    • version1version2 的所有修订号都可以存储在 32 位整数

    [054] 76.最小覆盖子串

    给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串,则返回空字符串 ""

    注意:

    • 对于 t 中重复字符,我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
    • 如果 s 中存在这样的子串,我们保证它是唯一的答案。

    示例 1:

    输入:s = "ADOBECODEBANC", t = "ABC"
    输出:"BANC"
    

    示例 2:

    输入:s = "a", t = "a"
    输出:"a"
    

    示例 3:

    输入: s = "a", t = "aa"
    输出: ""
    解释: t 中两个字符 'a' 均应包含在 s 的子串中,
    因此没有符合条件的子字符串,返回空字符串。

    提示:

    • 1 <= s.length, t.length <= 105
    • st 由英文字母组成

    进阶:你能设计一个在 o(n) 时间内解决此问题的算法吗?

    [055] 155.最小栈

    设计一个支持 pushpoptop 操作,并能在常数时间内检索到最小元素的栈。

    • push(x) —— 将元素 x 推入栈中。
    • pop() —— 删除栈顶的元素。
    • top() —— 获取栈顶元素。
    • getMin() —— 检索栈中的最小元素。

     

    示例:

    输入:
    ["MinStack","push","push","push","getMin","pop","top","getMin"]
    [[],[-2],[0],[-3],[],[],[],[]]
    
    输出:
    [null,null,null,null,-3,null,0,-2]
    
    解释:
    MinStack minStack = new MinStack();
    minStack.push(-2);
    minStack.push(0);
    minStack.push(-3);
    minStack.getMin();   --> 返回 -3.
    minStack.pop();
    minStack.top();      --> 返回 0.
    minStack.getMin();   --> 返回 -2.
    

     

    提示:

    • poptopgetMin 操作总是在 非空栈 上调用。

    [056] 322.零钱兑换

    给你一个整数数组 coins ,表示不同面额的硬币;以及一个整数 amount ,表示总金额。

    计算并返回可以凑成总金额所需的 最少的硬币个数 。如果没有任何一种硬币组合能组成总金额,返回 -1

    你可以认为每种硬币的数量是无限的。

    示例 1:

    输入:coins = [1, 2, 5], amount = 11
    输出:3 
    解释:11 = 5 + 5 + 1

    示例 2:

    输入:coins = [2], amount = 3
    输出:-1

    示例 3:

    输入:coins = [1], amount = 0
    输出:0
    

    示例 4:

    输入:coins = [1], amount = 1
    输出:1
    

    示例 5:

    输入:coins = [1], amount = 2
    输出:2
    

    提示:

    • 1 <= coins.length <= 12
    • 1 <= coins[i] <= 231 - 1
    • 0 <= amount <= 104

    [057] 78.子集

    给你一个整数数组 nums ,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。

    解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

    示例 1:

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

    示例 2:

    输入:nums = [0]
    输出:[[],[0]]
    

    提示:

    • 1 <= nums.length <= 10
    • -10 <= nums[i] <= 10
    • nums 中的所有元素 互不相同

    [058] 43.字符串相乘

    给定两个以字符串形式表示的非负整数 num1 和 num2,返回 num1 和 num2 的乘积,它们的乘积也表示为字符串形式。

    示例 1:

    输入: num1 = "2", num2 = "3"
    输出: "6"

    示例 2:

    输入: num1 = "123", num2 = "456"
    输出: "56088"

    说明:

    1. num1 和 num2 的长度小于110。
    2. num1 和 num2 只包含数字 0-9
    3. num1 和 num2 均不以零开头,除非是数字 0 本身。
    4. 不能使用任何标准库的大数类型(比如 BigInteger)直接将输入转换为整数来处理

    [059] 32.最长有效括号

    给你一个只包含 '('')' 的字符串,找出最长有效(格式正确且连续)括号子串的长度。

    示例 1:

    输入:s = "(()"
    输出:2
    解释:最长有效括号子串是 "()"
    

    示例 2:

    输入:s = ")()())"
    输出:4
    解释:最长有效括号子串是 "()()"
    

    示例 3:

    输入:s = ""
    输出:0
    

    提示:

    • 0 <= s.length <= 3 * 104
    • s[i]'('')'

    [060] 105.从前序与中序遍历序列构造二叉树

    给定一棵树的前序遍历 preorder 与中序遍历 inorder。请构造二叉树并返回其根节点。

    示例 1:

    Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
    Output: [3,9,20,null,null,15,7]
    

    示例 2:

    Input: preorder = [-1], inorder = [-1]
    Output: [-1]
    

    提示:

    • 1 <= preorder.length <= 3000
    • inorder.length == preorder.length
    • -3000 <= preorder[i], inorder[i] <= 3000
    • preorderinorder 均无重复元素
    • inorder 均出现在 preorder
    • preorder 保证为二叉树的前序遍历序列
    • inorder 保证为二叉树的中序遍历序列

    [061] 151.翻转字符串里的单词

    给你一个字符串 s ,逐个翻转字符串中的所有 单词

    单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

    请你返回一个翻转 s 中单词顺序并用单个空格相连的字符串。

    说明:

    • 输入字符串 s 可以在前面、后面或者单词间包含多余的空格。
    • 翻转后单词间应当仅用一个空格分隔。
    • 翻转后的字符串中不应包含额外的空格。

    示例 1:

    输入:s = "the sky is blue"
    输出:"blue is sky the"
    

    示例 2:

    输入:s = "  hello world  "
    输出:"world hello"
    解释:输入字符串可以在前面或者后面包含多余的空格,但是翻转后的字符不能包括。
    

    示例 3:

    输入:s = "a good   example"
    输出:"example good a"
    解释:如果两个单词间有多余的空格,将翻转后单词间的空格减少到只含一个。
    

    示例 4:

    输入:s = "  Bob    Loves  Alice   "
    输出:"Alice Loves Bob"
    

    示例 5:

    输入:s = "Alice does not even like bob"
    输出:"bob like even not does Alice"
    

    提示:

    • 1 <= s.length <= 104
    • s 包含英文大小写字母、数字和空格 ' '
    • s至少存在一个 单词

    进阶:

    • 请尝试使用 O(1) 额外空间复杂度的原地解法。

    [062] 144.二叉树的前序遍历

    给你二叉树的根节点 root ,返回它节点值的 前序 遍历。

    示例 1:

    输入:root = [1,null,2,3]
    输出:[1,2,3]
    

    示例 2:

    输入:root = []
    输出:[]
    

    示例 3:

    输入:root = [1]
    输出:[1]
    

    示例 4:

    输入:root = [1,2]
    输出:[1,2]
    

    示例 5:

    输入:root = [1,null,2]
    输出:[1,2]
    

    提示:

    • 树中节点数目在范围 [0, 100]
    • -100 <= Node.val <= 100

    进阶:递归算法很简单,你可以通过迭代算法完成吗?

    [063] 110.平衡二叉树

    给定一个二叉树,判断它是否是高度平衡的二叉树。

    本题中,一棵高度平衡二叉树定义为:

    一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

    示例 1:

    输入:root = [3,9,20,null,null,15,7]
    输出:true
    

    示例 2:

    输入:root = [1,2,2,3,3,null,null,4,4]
    输出:false
    

    示例 3:

    输入:root = []
    输出:true
    

    提示:

    • 树中的节点数在范围 [0, 5000]
    • -104 <= Node.val <= 104

    [064] 101.对称二叉树

    给定一个二叉树,检查它是否是镜像对称的。

     

    例如,二叉树 [1,2,2,3,4,4,3] 是对称的。

        1
       / \
      2   2
     / \ / \
    3  4 4  3
    

     

    但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

        1
       / \
      2   2
       \   \
       3    3
    

     

    进阶:

    你可以运用递归和迭代两种方法解决这个问题吗?

    [065] 104.二叉树的最大深度

    给定一个二叉树,找出其最大深度。

    二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

    说明: 叶子节点是指没有子节点的节点。

    示例:
    给定二叉树 [3,9,20,null,null,15,7]

        3
       / \
      9  20
        /  \
       15   7

    返回它的最大深度 3 。

    [066] 129.求根到叶子节点数字之和

    给你一个二叉树的根节点 root ,树中每个节点都存放有一个 09 之间的数字。

    每条从根节点到叶节点的路径都代表一个数字:

    • 例如,从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123

    计算从根节点到叶节点生成的 所有数字之和

    叶节点 是指没有子节点的节点。

    示例 1:

    输入:root = [1,2,3]
    输出:25
    解释:
    从根到叶子节点路径 1->2 代表数字 12
    从根到叶子节点路径 1->3 代表数字 13
    因此,数字总和 = 12 + 13 = 25

    示例 2:

    输入:root = [4,9,0,5,1]
    输出:1026
    解释:
    从根到叶子节点路径 4->9->5 代表数字 495
    从根到叶子节点路径 4->9->1 代表数字 491
    从根到叶子节点路径 4->0 代表数字 40
    因此,数字总和 = 495 + 491 + 40 = 1026
    

    提示:

    • 树中节点的数目在范围 [1, 1000]
    • 0 <= Node.val <= 9
    • 树的深度不超过 10

    [067] 543.二叉树的直径

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

     

    示例 :
    给定二叉树

              1
             / \
            2   3
           / \     
          4   5    
    

    返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。

     

    注意:两结点之间的路径长度是以它们之间边的数目表示。

    [068] 470.用 Rand7() 实现 Rand10()

    已有方法 rand7 可生成 1 到 7 范围内的均匀随机整数,试写一个方法 rand10 生成 1 到 10 范围内的均匀随机整数。

    不要使用系统的 Math.random() 方法。

     

    示例 1:

    输入: 1
    输出: [7]
    

    示例 2:

    输入: 2
    输出: [8,4]
    

    示例 3:

    输入: 3
    输出: [8,1,10]
    

     

    提示:

    1. rand7 已定义。
    2. 传入参数: n 表示 rand10 的调用次数。

     

    进阶:

    1. rand7()调用次数的 期望值 是多少 ?
    2. 你能否尽量少调用 rand7() ?

    [069] 113.路径总和 II

    给你二叉树的根节点 root 和一个整数目标和 targetSum ,找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

    叶子节点 是指没有子节点的节点。

    示例 1:

    输入:root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
    输出:[[5,4,11,2],[5,8,4,5]]
    

    示例 2:

    输入:root = [1,2,3], targetSum = 5
    输出:[]
    

    示例 3:

    输入:root = [1,2], targetSum = 0
    输出:[]
    

    提示:

    • 树中节点总数在范围 [0, 5000]
    • -1000 <= Node.val <= 1000
    • -1000 <= targetSum <= 1000

    [070] 98.验证二叉搜索树

    给你一个二叉树的根节点 root ,判断其是否是一个有效的二叉搜索树。

    有效 二叉搜索树定义如下:

    • 节点的左子树只包含 小于 当前节点的数。
    • 节点的右子树只包含 大于 当前节点的数。
    • 所有左子树和右子树自身必须也是二叉搜索树。

     

    示例 1:

    输入:root = [2,1,3]
    输出:true
    

    示例 2:

    输入:root = [5,1,4,null,null,3,6]
    输出:false
    解释:根节点的值是 5 ,但是右子节点的值是 4 。
    

     

    提示:

    • 树中节点数目范围在[1, 104]
    • -231 <= Node.val <= 231 - 1

    [071] 64.最小路径和

    给定一个包含非负整数的 m x n 网格 grid ,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。

    说明:每次只能向下或者向右移动一步。

    示例 1:

    输入:grid = [[1,3,1],[1,5,1],[4,2,1]]
    输出:7
    解释:因为路径 1→3→1→1→1 的总和最小。
    

    示例 2:

    输入:grid = [[1,2,3],[4,5,6]]
    输出:12
    

    提示:

    • m == grid.length
    • n == grid[i].length
    • 1 <= m, n <= 200
    • 0 <= grid[i][j] <= 100

    [072] 48.旋转图像

    给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

    你必须在 原地 旋转图像,这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

    示例 1:

    输入:matrix = [[1,2,3],[4,5,6],[7,8,9]]
    输出:[[7,4,1],[8,5,2],[9,6,3]]
    

    示例 2:

    输入:matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
    输出:[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
    

    示例 3:

    输入:matrix = [[1]]
    输出:[[1]]
    

    示例 4:

    输入:matrix = [[1,2],[3,4]]
    输出:[[3,1],[4,2]]
    

    提示:

    • matrix.length == n
    • matrix[i].length == n
    • 1 <= n <= 20
    • -1000 <= matrix[i][j] <= 1000

    [073] 112.路径总和

    给你二叉树的根节点 root 和一个表示目标和的整数 targetSum ,判断该树中是否存在 根节点到叶子节点 的路径,这条路径上所有节点值相加等于目标和 targetSum

    叶子节点 是指没有子节点的节点。

    示例 1:

    输入:root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
    输出:true
    

    示例 2:

    输入:root = [1,2,3], targetSum = 5
    输出:false
    

    示例 3:

    输入:root = [1,2], targetSum = 0
    输出:false
    

    提示:

    • 树中节点的数目在范围 [0, 5000]
    • -1000 <= Node.val <= 1000
    • -1000 <= targetSum <= 1000

    [074] 39.组合总和

    给定一个无重复元素的正整数数组 candidates 和一个正整数 target ,找出 candidates 中所有可以使数字和为目标数 target 的唯一组合。

    candidates 中的数字可以无限制重复被选取。如果至少一个所选数字数量不同,则两种组合是唯一的。

    对于给定的输入,保证和为 target 的唯一组合数少于 150 个。

    示例 1:

    输入: candidates = [2,3,6,7], target = 7
    输出: [[7],[2,2,3]]
    

    示例 2:

    输入: candidates = [2,3,5], target = 8
    输出: [[2,2,2,2],[2,3,3],[3,5]]

    示例 3:

    输入: candidates = [2], target = 1
    输出: []
    

    示例 4:

    输入: candidates = [1], target = 1
    输出: [[1]]
    

    示例 5:

    输入: candidates = [1], target = 2
    输出: [[1,1]]
    

    提示:

    • 1 <= candidates.length <= 30
    • 1 <= candidates[i] <= 200
    • candidate 中的每个元素都是独一无二的。
    • 1 <= target <= 500

    [075] 234.回文链表

    给你一个单链表的头节点 head ,请你判断该链表是否为回文链表。如果是,返回 true ;否则,返回 false

     

    示例 1:

    输入:head = [1,2,2,1]
    输出:true
    

    示例 2:

    输入:head = [1,2]
    输出:false
    

     

    提示:

    • 链表中节点数目在范围[1, 105]
    • 0 <= Node.val <= 9

     

    进阶:你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?

    [076] 394.字符串解码

    给定一个经过编码的字符串,返回它解码后的字符串。

    编码规则为: k[encoded_string],表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

    你可以认为输入字符串总是有效的;输入字符串中没有额外的空格,且输入的方括号总是符合格式要求的。

    此外,你可以认为原始数据不包含数字,所有的数字只表示重复的次数 k ,例如不会出现像 3a 或 2[4] 的输入。

     

    示例 1:

    输入:s = "3[a]2[bc]"
    输出:"aaabcbc"
    

    示例 2:

    输入:s = "3[a2[c]]"
    输出:"accaccacc"
    

    示例 3:

    输入:s = "2[abc]3[cd]ef"
    输出:"abcabccdcdcdef"
    

    示例 4:

    输入:s = "abc3[cd]xyz"
    输出:"abccdcdcdxyz"
    

    [077] 169.多数元素

    给定一个大小为 n 的数组,找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

    你可以假设数组是非空的,并且给定的数组总是存在多数元素。

    示例 1:

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

    示例 2:

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

    进阶:

    • 尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。

    [078] 221.最大正方形

    在一个由 '0''1' 组成的二维矩阵内,找到只包含 '1' 的最大正方形,并返回其面积。

    示例 1:

    输入:matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
    输出:4
    

    示例 2:

    输入:matrix = [["0","1"],["1","0"]]
    输出:1
    

    示例 3:

    输入:matrix = [["0"]]
    输出:0
    

    提示:

    • m == matrix.length
    • n == matrix[i].length
    • 1 <= m, n <= 300
    • matrix[i][j]'0''1'

    [079] 34.在排序数组中查找元素的第一个和最后一个位置

    给定一个按照升序排列的整数数组 nums,和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

    如果数组中不存在目标值 target,返回 [-1, -1]

    进阶:

    • 你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗?

    示例 1:

    输入:nums = [5,7,7,8,8,10], target = 8
    输出:[3,4]

    示例 2:

    输入:nums = [5,7,7,8,8,10], target = 6
    输出:[-1,-1]

    示例 3:

    输入:nums = [], target = 0
    输出:[-1,-1]

    提示:

    • 0 <= nums.length <= 105
    • -109 <= nums[i] <= 109
    • nums 是一个非递减数组
    • -109 <= target <= 109

    [080] 718.最长重复子数组

    给两个整数数组 A 和 B ,返回两个数组中公共的、长度最长的子数组的长度。

     

    示例:

    输入:
    A: [1,2,3,2,1]
    B: [3,2,1,4,7]
    输出:3
    解释:
    长度最长的公共子数组是 [3, 2, 1] 。
    

     

    提示:

    • 1 <= len(A), len(B) <= 1000
    • 0 <= A[i], B[i] < 100

    [081] 240.搜索二维矩阵 II

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

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

     

    示例 1:

    输入: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
    

    示例 2:

    输入: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 = 20
    输出:false
    

     

    提示:

    • m == matrix.length
    • n == matrix[i].length
    • 1 <= n, m <= 300
    • -109 <= matrix[i][j] <= 109
    • 每行的所有元素从左到右升序排列
    • 每列的所有元素从上到下升序排列
    • -109 <= target <= 109

    [082] 226.翻转二叉树

    翻转一棵二叉树。

    示例:

    输入:

         4
       /   \
      2     7
     / \   / \
    1   3 6   9

    输出:

         4
       /   \
      7     2
     / \   / \
    9   6 3   1

    备注:
    这个问题是受到 Max Howell 原问题 启发的 :

    谷歌:我们90%的工程师使用您编写的软件(Homebrew),但是您却无法在面试时在白板上写出翻转二叉树这道题,这太糟糕了。

    [083] 14.最长公共前缀

    编写一个函数来查找字符串数组中的最长公共前缀。

    如果不存在公共前缀,返回空字符串 ""

     

    示例 1:

    输入:strs = ["flower","flow","flight"]
    输出:"fl"
    

    示例 2:

    输入:strs = ["dog","racecar","car"]
    输出:""
    解释:输入不存在公共前缀。

     

    提示:

    • 1 <= strs.length <= 200
    • 0 <= strs[i].length <= 200
    • strs[i] 仅由小写英文字母组成

    [084] 128.最长连续序列

    给定一个未排序的整数数组 nums ,找出数字连续的最长序列(不要求序列元素在原数组中连续)的长度。

    请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

    示例 1:

    输入:nums = [100,4,200,1,3,2]
    输出:4
    解释:最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

    示例 2:

    输入:nums = [0,3,7,2,5,8,4,6,0,1]
    输出:9
    

    提示:

    • 0 <= nums.length <= 105
    • -109 <= nums[i] <= 109

    [085] 62.不同路径

    一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为 “Start” )。

    机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为 “Finish” )。

    问总共有多少条不同的路径?

    示例 1:

    输入:m = 3, n = 7
    输出:28

    示例 2:

    输入:m = 3, n = 2
    输出:3
    解释:
    从左上角开始,总共有 3 条路径可以到达右下角。
    1. 向右 -> 向下 -> 向下
    2. 向下 -> 向下 -> 向右
    3. 向下 -> 向右 -> 向下
    

    示例 3:

    输入:m = 7, n = 3
    输出:28
    

    示例 4:

    输入:m = 3, n = 3
    输出:6

    提示:

    • 1 <= m, n <= 100
    • 题目数据保证答案小于等于 2 * 109

    [086] 162.寻找峰值

    峰值元素是指其值严格大于左右相邻值的元素。

    给你一个整数数组 nums,找到峰值元素并返回其索引。数组可能包含多个峰值,在这种情况下,返回 任何一个峰值 所在位置即可。

    你可以假设 nums[-1] = nums[n] = -∞

    你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

     

    示例 1:

    输入:nums = [1,2,3,1]
    输出:2
    解释:3 是峰值元素,你的函数应该返回其索引 2。

    示例 2:

    输入:nums = [1,2,1,3,5,6,4]
    输出:1 或 5 
    解释:你的函数可以返回索引 1,其峰值元素为 2;
         或者返回索引 5, 其峰值元素为 6。
    

     

    提示:

    • 1 <= nums.length <= 1000
    • -231 <= nums[i] <= 231 - 1
    • 对于所有有效的 i 都有 nums[i] != nums[i + 1]

    [087] 227.基本计算器 II

    给你一个字符串表达式 s ,请你实现一个基本计算器来计算并返回它的值。

    整数除法仅保留整数部分。

    示例 1:

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

    示例 2:

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

    示例 3:

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

    提示:

    • 1 <= s.length <= 3 * 105
    • s 由整数和算符 ('+', '-', '*', '/') 组成,中间由一些空格隔开
    • s 表示一个 有效表达式
    • 表达式中的所有整数都是非负整数,且在范围 [0, 231 - 1]
    • 题目数据保证答案是一个 32-bit 整数

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

    存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除所有重复的元素,使每个元素 只出现一次

    返回同样按升序排列的结果链表。

    示例 1:

    输入:head = [1,1,2]
    输出:[1,2]
    

    示例 2:

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

    提示:

    • 链表中节点数目在范围 [0, 300]
    • -100 <= Node.val <= 100
    • 题目数据保证链表已经按升序排列

    [089] 122.买卖股票的最佳时机 II

    给定一个数组 prices ,其中 prices[i] 是一支给定股票第 i 天的价格。

    设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。

    注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

    示例 1:

    输入: prices = [7,1,5,3,6,4]
    输出: 7
    解释: 在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
         随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
    

    示例 2:

    输入: prices = [1,2,3,4,5]
    输出: 4
    解释: 在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
         注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。
    

    示例 3:

    输入: prices = [7,6,4,3,1]
    输出: 0
    解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

    提示:

    • 1 <= prices.length <= 3 * 104
    • 0 <= prices[i] <= 104

    [090] 695.岛屿的最大面积

    给你一个大小为 m x n 的二进制矩阵 grid

    岛屿 是由一些相邻的 1 (代表土地) 构成的组合,这里的「相邻」要求两个 1 必须在 水平或者竖直的四个方向上 相邻。你可以假设 grid 的四个边缘都被 0(代表水)包围着。

    岛屿的面积是岛上值为 1 的单元格的数目。

    计算并返回 grid 中最大的岛屿面积。如果没有岛屿,则返回面积为 0

     

    示例 1:

    输入:grid = [[0,0,1,0,0,0,0,1,0,0,0,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,1,1,0,1,0,0,0,0,0,0,0,0],[0,1,0,0,1,1,0,0,1,0,1,0,0],[0,1,0,0,1,1,0,0,1,1,1,0,0],[0,0,0,0,0,0,0,0,0,0,1,0,0],[0,0,0,0,0,0,0,1,1,1,0,0,0],[0,0,0,0,0,0,0,1,1,0,0,0,0]]
    输出:6
    解释:答案不应该是 11 ,因为岛屿只能包含水平或垂直这四个方向上的 1

    示例 2:

    输入:grid = [[0,0,0,0,0,0,0,0]]
    输出:0
    

     

    提示:

    • m == grid.length
    • n == grid[i].length
    • 1 <= m, n <= 50
    • grid[i][j]01

    [091] 139.单词拆分

    给定一个非空字符串 s 和一个包含非空单词的列表 wordDict,判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。

    说明:

    • 拆分时可以重复使用字典中的单词。
    • 你可以假设字典中没有重复的单词。

    示例 1:

    输入: s = "leetcode", wordDict = ["leet", "code"]
    输出: true
    解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。
    

    示例 2:

    输入: s = "applepenapple", wordDict = ["apple", "pen"]
    输出: true
    解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
         注意你可以重复使用字典中的单词。
    

    示例 3:

    输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
    输出: false
    

    [092] 198.打家劫舍

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

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

    示例 1:

    输入:[1,2,3,1]
    输出:4
    解释:偷窃 1 号房屋 (金额 = 1) ,然后偷窃 3 号房屋 (金额 = 3)。
         偷窃到的最高金额 = 1 + 3 = 4 。

    示例 2:

    输入:[2,7,9,3,1]
    输出:12
    解释:偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9),接着偷窃 5 号房屋 (金额 = 1)。
         偷窃到的最高金额 = 2 + 9 + 1 = 12 。
    

    提示:

    • 1 <= nums.length <= 100
    • 0 <= nums[i] <= 400

    [093] 179.最大数

    给定一组非负整数 nums,重新排列每个数的顺序(每个数不可拆分)使之组成一个最大的整数。

    注意:输出结果可能非常大,所以你需要返回一个字符串而不是整数。

    示例 1:

    输入nums = [10,2]
    输出:"210"

    示例 2:

    输入nums = [3,30,34,5,9]
    输出:"9534330"
    

    示例 3:

    输入nums = [1]
    输出:"1"
    

    示例 4:

    输入nums = [10]
    输出:"10"
    

    提示:

    • 1 <= nums.length <= 100
    • 0 <= nums[i] <= 109

    [094] 662.二叉树最大宽度

    给定一个二叉树,编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树(full binary tree)结构相同,但一些节点为空。

    每一层的宽度被定义为两个端点(该层最左和最右的非空节点,两端点间的null节点也计入长度)之间的长度。

    示例 1:

    输入: 
    
               1
             /   \
            3     2
           / \     \  
          5   3     9 
    
    输出: 4
    解释: 最大值出现在树的第 3 层,宽度为 4 (5,3,null,9)。
    

    示例 2:

    输入: 
    
              1
             /  
            3    
           / \       
          5   3     
    
    输出: 2
    解释: 最大值出现在树的第 3 层,宽度为 2 (5,3)。
    

    示例 3:

    输入: 
    
              1
             / \
            3   2 
           /        
          5      
    
    输出: 2
    解释: 最大值出现在树的第 2 层,宽度为 2 (3,2)。
    

    示例 4:

    输入: 
    
              1
             / \
            3   2
           /     \  
          5       9 
         /         \
        6           7
    输出: 8
    解释: 最大值出现在树的第 4 层,宽度为 8 (6,null,null,null,null,null,null,7)。
    

    注意: 答案在32位有符号整数的表示范围内。

    [095] 补充题6.手撕堆排序

    给你一个整数数组 nums,请你将该数组升序排列。

     

      示例 1:

      输入:nums = [5,2,3,1]输出:[1,2,3,5]

      示例 2:

      输入:nums = [5,1,1,2,0,0]输出:[0,0,1,1,2,5]

       

      提示:

      1. 1 <= nums.length <= 50000
      2. -50000 <= nums[i] <= 50000

      [096] 153.寻找旋转排序数组中的最小值

      已知一个长度为 n 的数组,预先按照升序排列,经由 1n旋转 后,得到输入数组。例如,原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到:
      • 若旋转 4 次,则可以得到 [4,5,6,7,0,1,2]
      • 若旋转 7 次,则可以得到 [0,1,2,4,5,6,7]

      注意,数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1], a[2], ..., a[n-2]]

      给你一个元素值 互不相同 的数组 nums ,它原来是一个升序排列的数组,并按上述情形进行了多次旋转。请你找出并返回数组中的 最小元素

      示例 1:

      输入:nums = [3,4,5,1,2]
      输出:1
      解释:原数组为 [1,2,3,4,5] ,旋转 3 次得到输入数组。
      

      示例 2:

      输入:nums = [4,5,6,7,0,1,2]
      输出:0
      解释:原数组为 [0,1,2,4,5,6,7] ,旋转 4 次得到输入数组。
      

      示例 3:

      输入:nums = [11,13,15,17]
      输出:11
      解释:原数组为 [11,13,15,17] ,旋转 4 次得到输入数组。
      

      提示:

      • n == nums.length
      • 1 <= n <= 5000
      • -5000 <= nums[i] <= 5000
      • nums 中的所有整数 互不相同
      • nums 原来是一个升序排序的数组,并进行了 1n 次旋转

      [097] 24.两两交换链表中的节点

      给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。

      你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。

      示例 1:

      输入:head = [1,2,3,4]
      输出:[2,1,4,3]
      

      示例 2:

      输入:head = []
      输出:[]
      

      示例 3:

      输入:head = [1]
      输出:[1]
      

      提示:

      • 链表中节点的数目在范围 [0, 100]
      • 0 <= Node.val <= 100

      进阶:你能在不修改链表节点值的情况下解决这个问题吗?(也就是说,仅修改节点本身。)

      [098] 152.乘积最大子数组

      给你一个整数数组 nums ,请你找出数组中乘积最大的连续子数组(该子数组中至少包含一个数字),并返回该子数组所对应的乘积。

       

      示例 1:

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

      示例 2:

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

      [099] 297.二叉树的序列化与反序列化

      序列化是将一个数据结构或者对象转换为连续的比特位的操作,进而可以将转换后的数据存储在一个文件或者内存中,同时也可以通过网络传输到另一个计算机环境,采取相反方式重构得到原数据。

      请设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑,你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。

      提示: 输入输出格式与 LeetCode 目前使用的方式一致,详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式,你也可以采用其他的方法解决这个问题。

      示例 1:

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

      示例 2:

      输入:root = []
      输出:[]
      

      示例 3:

      输入:root = [1]
      输出:[1]
      

      示例 4:

      输入:root = [1,2]
      输出:[1,2]
      

      提示:

      • 树中结点数在范围 [0, 104]
      • -1000 <= Node.val <= 1000

      [100] 283.移动零

      给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。

      示例:

      输入: [0,1,0,3,12]
      输出: [1,3,12,0,0]

      说明:

      1. 必须在原数组上操作,不能拷贝额外的数组。
      2. 尽量减少操作次数。