Java硬件工程师的博客

问题描述给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。整数除法仅保留整数部分。示例 1：输入：s = "3+2*2"输出：7示例 2：输入：s = " 3/2 "输出：1示例 3：输入：s = " 3+5 / 2 "输出：5提示：1 <= s.length <= 3 * 105s 由整数和算符 ('+', '-', '*', '/') 组成，中间由一些空格隔开s 表示一个 有效表达式表达式中的所有整数都是非负整数，且在范围 [0, 2

问题描述假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] 。请找出其中最小的元素。示例 1：输入：nums = [3,4,5,1,2]输出：1示例 2：输入：nums = [4,5,6,7,0,1,2]输出：0示例 3：输入：nums = [1]输出：1提示：1 <= nums.length <= 5000-5000 <= nums[i] <= 5000num

问题描述峰值元素是指其值大于左右相邻值的元素。给你一个输入数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。你可以假设 nums[-1] = nums[n] = -∞ 。示例 1：输入：nums = [1,2,3,1]输出：2解释：3 是峰值元素，你的函数应该返回其索引 2。示例 2：输入：nums = [1,2,1,3,5,6,4]输出：1 或 5 解释：你的函数可以返回索引 1，其峰值元素为 2； 或者返回索

问题描述给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。你可以对一个单词进行如下三种操作：插入一个字符删除一个字符替换一个字符示例 1：输入：word1 = "horse", word2 = "ros"输出：3解释：horse -> rorse (将 'h' 替换为 'r')rorse -> rose (删除 'r')rose -> ros (删除 'e')示例 2：输入：word1 = "inte

问题描述输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。示例 1:给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7返回 true 。示例 2:给定二叉树 [1,2,2,3,3,null,null,4,4] 1 / \ 2 2 / \ 3 3 / \ 4 4

问题描述给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 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,

问题描述输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如，给出前序遍历 preorder = [3,9,20,15,7]中序遍历 inorder = [9,3,15,20,7]返回如下的二叉树： 3 / \ 9 20 / \ 15 7 限制：0 <= 节点个数 <= 5000解题思路：对于任意一颗树而言，前序遍历的形式总是[ 根节点, [左子树的前序遍历结果],

问题描述给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 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,n

问题描述给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。返回符合要求的 最少分割次数 。示例 1：输入：s = "aab"输出：1解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。示例 2：输入：s = "a"输出：0示例 3：输入：s = "ab"输出：1 提示：1 <= s.length <= 2000s 仅由小写英文字母组成解题思路设 f[i]表示字符串的前缀 s[0…i]的最少分割次数。要想得出

问题描述给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。回文串 是正着读和反着读都一样的字符串。示例 1：输入：s = "aab"输出：[["a","a","b"],["aa","b"]]示例 2：输入：s = "a"输出：[["a"]] 提示：1 <= s.length <= 16s 仅由小写英文字母组成解题思路：回溯 + 动态规划预处理由于需要求出字符串 s 的所有分割方案，因此我们考虑使用搜索 + 回

问题描述给你一个字符串 s，找到 s 中最长的回文子串。示例 1：输入：s = "babad"输出："bab"解释："aba" 同样是符合题意的答案。示例 2：输入：s = "cbbd"输出："bb"示例 3：输入：s = "a"输出："a"示例 4：输入：s = "ac"输出："a" 提示：1 <= s.length <= 1000s 仅由数字和英文字母（大写和/或小写）组成解题思路对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首

问题描述给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, …）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。给你一个整数 n ，返回和为 n 的完全平方数的 最少数量 。完全平方数 是一个整数，其值等于另一个整数的平方；换句话说，其值等于一个整数自乘的积。例如，1、4、9 和 16 都是完全平方数，而 3 和 11 不是。示例 1：输入：n = 12输出：3 解释：12 = 4 + 4 + 4示例 2：输入：n = 13输出：2解释：13 = 4 +

问题描述给定一组非负整数 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

问题描述给你一个长度为 n 的整数数组 nums，其中 n > 1，返回输出数组 output ，其中 output[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。示例:输入: [1,2,3,4]输出: [24,12,8,6]提示：题目数据保证数组之中任意元素的全部前缀元素和后缀（甚至是整个数组）的乘积都在 32 位整数范围内。说明: 请不要使用除法，且在 O(n) 时间复杂度内完成此题。进阶：你可以在常数空间复杂度内完成这个题目吗？（ 出于对空间复杂度分析的目的

买卖股票的最佳时机I问题描述给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。示例 1：输入：[7,1,5,3,6,4]输出：5解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 =

问题描述你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。示例 1：输入：[1,2,3,1]输出：4解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。 偷窃到的最高金额 = 1 + 3 = 4 。示例 2：输

所谓线性DP是，是指我们的递推方程是有着明显的线性关系的。动态规划中每个状态都是多维的状态，多维状态有一个求解的顺序，比如背包问题是一个二维的，求的时候一行一行的来求，这样的DP我们称之为线性DP。数字三角形问题描述给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。 7 3 8 8 1 0 2 7 4 44 5 2

问题描述给定一个非空的整数数组，返回其中出现频率前 k 高的元素。示例 1:输入: nums = [1,1,1,2,2,3], k = 2输出: [1,2]示例 2:输入: nums = [1], k = 1输出: [1]提示：你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。你可以按任意顺序返回答案。

问题描述给定一个 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

背包问题简介：有 N 件物品和一个容量是 V 的背包。每个物品有两个属性体积和价值，第 i 件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。01背包问题：每件物品最多只能用一次。要么0次，要么1次。完全背包问题：每件物品有无限个选择，我们尽可能的装入进去，来保证总价值最大多重背包问题：每个物品的个数不一样，最多有si个。分组背包问题：物品有N组，每一组物品里面有若干个。每一组里面最多只能选择一个物品所以我们可以发现背包问题，本质上是给

问题描述给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。示例 1：输入：nums = [1,2,0]输出：3示例 2：输入：nums = [3,4,-1,1]输出：2示例 3：输入：nums = [7,8,9,11,12]输出：1提示：0 <= nums.length <= 300-231 <= nums[i] <= 231 - 1解题思路：若有时间复杂度和空间负责度的要求，则解题相当的困难，如果不做要求的话，本题可以将

问题描述给你一个由 ‘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 = [

目录二叉树的前中后序遍历框架二叉树的前序遍历问题描述解题思路：实现代码二叉树的后序遍历问题描述解题思路实现代码二叉树的中序遍历问题描述解题思路：实现代码总结：相信大家对二叉树的前中后序遍历的递归方法非常熟悉，其实就是一个类似的框架if(p!=null){ //前序遍历时访问结点 if(p.left!=null){ //递归进入左子节点遍历 } //中序遍历时访问结点 if(p.right!=null){ //递归进入右子节点遍历 } //后序遍历时访问结点}可以看到，写前中后

问题描述输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。示例 1：输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]输出：true解释：我们可以按以下顺序执行：push(1), push(2), push(3), pu

问题描述输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。例如：给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7返回它的最大深度 3 。解题思路深度优先搜索(DFS)也可以理解为二叉树的递归遍历，我们将二叉树的深度作为参数，然后进行二叉树的递归遍历，当遍历到叶结点的时候，就将父节点的深度与当前最大深度进行比较，如果父节点的

问题描述给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵 高度平衡 二叉搜索树。高度平衡 二叉树是一棵满足「每个节点的左右两个子树的高度差的绝对值不超过 1 」的二叉树。示例 1：输入：nums = [-10,-3,0,5,9]输出：[0,-3,9,-10,null,5]解释：[0,-10,5,null,-3,null,9] 也将被视为正确答案：示例 2：输入：nums = [1,3]输出：[3,1]解释：[1,3] 和 [3,1] 都是高度平衡二叉搜

问题描述：颠倒给定的 32 位无符号整数的二进制位。示例 1：输入: 00000010100101000001111010011100输出: 00111001011110000010100101000000解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596， 因此返回 964176192，其二进制表示形式为 00111001011110000010100101000000。示例 2：输入：11111111111

问题描述给定一个整数 n，返回 n! 结果尾数中零的数量。示例 1:输入: 3输出: 0解释: 3! = 6, 尾数中没有零。示例 2:输入: 5输出: 1解释: 5! = 120, 尾数中有 1 个零.说明: 你算法的时间复杂度应为 O(log n) 。解题思路：方法1：首先，很容易想到，先求得n！，然后再计算尾数中0的个数，但时间复杂度太高方法2：可以发现，如果尾数中有x个0，那么在n！的算式中一定存在x个25，所以只要能够得到 n ！ 的算式中分解出的25的个数即可，

1.问题描述给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。示例 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

问题描述用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )示例 1：输入：["CQueue","appendTail","deleteHead","deleteHead"][[],[3],[],[]]输出：[null,null,3,-1]示例 2：输入：["CQueue","deleteHead","appendTai

问题描述给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。示例:输入: 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

问题描述定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。示例:MinStack minStack = new MinStack();minStack.push(-2);minStack.push(0);minStack.push(-3);minStack.min(); --> 返回 -3.minStack.pop();minStack.top(); --> 返回 0

问题描述以数组 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],

问题描述给你一个包含 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-

问题描述请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。示例 1:输入: "abcabcbb"输出: 3 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。示例 2:输入: "bbbbb"输出: 1解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。示例 3:输入: "pwwkew"输出: 3解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，"pwke" 是

1.问题描述统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。请注意，你可以假定字符串里不包括任何不可打印的字符。示例:输入: "Hello, my name is John"输出: 5解释: 这里的单词是指连续的不是空格的字符，所以 "Hello," 算作 1 个单词。2.解题思路统计单词次数可以使用双指针法大雪菜老师给出的模板如下for (int i = 0, j = 0; i < n; i ++ ){ while (j < i &&amp

1.LRU算法是什么？LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法选择最近最久未使用的数据予以淘汰。除此之外，在redis缓存中也是用到了这种算法。redis有读写两个操作，然后缓存是有空间限制的，大小会有一定上线的，2.算法来源来自https://leetcode-cn.com/problems/lru-cache/运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。实现 LRUCache 类：LRUCache(

问题描述给定一个按照升序排列的整数数组 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

问题描述输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。示例1：输入：1->2->4, 1->3->4输出：1->1->2->3->4->4限制：0 <= 链表长度 <= 1000解题思路本题与普通数组的归并十分相似，根据题目描述，两个链表l1，l2是递增的，因此很容易想到使用双指针l1和l2来遍历两个链表，根据双指针所指向的l1.val和l2.val的大小关系确定添加结点的顺序，当l1.val更小

本题来自剑指 Offer 06. 从尾到头打印链表问题描述输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。示例 1：输入：head = [1,3,2]输出：[2,3,1]解题思路：方式1：先将单链表进行反转操作，然后再遍历链表即可，这样做的问题是会破坏原来的单链表结构，不建议。关于链表的反转操作可以参看反转链表方式2：可以利用栈这个数据结构，将各个结点压入到栈中，然后利用栈的后进先出的特点，实现了逆序打印的效果。关于Java中栈Stack类的使用和操作可以参看Jav