Tag - "LeetCode"
2022
乘积最大子数组-LeetCode152
2022 年 04 月 15 日
题目描述 链接: https://leetcode-cn.com/problems/maximum-product-subarray/
给你一个整数数组nums, 请你找出数组中成绩最大的非空连续子数组(该子数组中至少包含一个数字), 并返回该子数组所对应的乘积.
示例1:
输入: [2, 3, -2, 4]
输出: 6
子数组 [2, 3]得到最大乘积6
输入 [-2, 0 -,1]
输出: 0
乘积为正数的最长子数组长度-LeetCode1567
2022 年 04 月 15 日
题目描述 链接: https://leetcode-cn.com/problems/maximum-length-of-subarray-with-positive-product/
给定一个整数数组nums, 求乘积为正数的最长子数组的长度
示例1:
输入: [1, -2, -3, 4]
输出: 4
数组本身乘积就是正数
示例2:
输入: [0, 1, -2, -3, -4]
输出: 3
最长乘积为整数的子数组为[1, -2, -3]
最大子数组和-LeetCode53
2022 年 04 月 14 日
题目描述 链接: https://leetcode-cn.com/problems/maximum-subarray/
给你一个整数数组nums, 请你找出一个具有最大和的连续子数组(子数组最少包含一个元素), 返回其最大和
子数组是数组中的一个连续部分
示例1:
输入: nums =[-2, 1, -3, 4, -1, 2, 1, -5, 4]
输出: 6
连续子数组 [4, -1, 2, 1]的和最大, 为6.
示例2:
输入: nums = [1]
输出: 1
示例3:
输入: nums = [5, 4, -1, 7, 8]
输出: 23
跳跃游戏2-LeetCode45
2022 年 04 月 14 日
题目描述 链接: https://leetcode-cn.com/problems/jump-game-ii/
给定一个非负整数数组nums, 最初位于数组的第一个位置. 数组中的每个元素代表你在该位置上可以跳跃的最大长度.
你的目标是使用最少的跳跃次数到达数组的最后一个位置. 求最少需要跳跃几次, 假设总是可以到达数组的最后一个位置.
示例1:
输入: nums = [2, 3, 1, 1, 4]
输出: 2
从下标0跳到下标1, 再从下标1跳3步到最后一个位置. 总共跳跃2次
示例2:
输入: nums = [2, 3, 0, 1, 4]
输出: 2
跳跃游戏-LeetCode55
2022 年 04 月 14 日
题目描述 链接: https://leetcode-cn.com/problems/jump-game/
给定一个非负整数数组nums, 你最初位于数组的第一个下标, 数组中的每个元素代表你在该位置可以跳跃的最大长度.
判断你是否能够到达最后一个下标
示例1:
输入: nums=[2, 3, 1, 1, 4]
输出: true
可以先从下标0走1步到下标1, 然后从下标1走3步到最后一个下标
示例2:
输入: nums = [3, 2, 1, 0, 4]
输出: false
无论怎么走, 都会走到下标3的位置, 到了这里无法在继续往前走. 所以不可能到达最后一个坐标
环形子数组的最大和-LeetCode918
2022 年 04 月 14 日
题目描述 链接: https://leetcode-cn.com/problems/maximum-sum-circular-subarray/
给定一个长度为n的环形整数数组nums, 返回nums的非空子数组的最大和
环形数组意味着数组的末端和头部是相连的, 所以子数组可以为数组的中间某一段或者首尾两段.
示例1:
输入: nums = [1, -1, 3, -2]
输出: 3
子数组 [3] 为最大和
示例2:
输入: nums = [5, -3, 5]
输出: 10
首尾的子数组[5, 5]得到最大和10
示例3:
输入: [3, -2, 2, -3]
输出: 3
从子数组[3], [3, -2, 2]都可以得到最大和3
使用最小花费爬楼梯-LeetCode746
2022 年 04 月 13 日
题目描述 链接: https://leetcode-cn.com/problems/min-cost-climbing-stairs/
给定一个整数数组cost, 其中cost[i]表示从楼梯第i个台阶向上爬需要支付的费用. 每次只能向上爬一个或两个台阶.
可以从下标0或下标1的台阶开始爬楼梯.
求到达楼梯顶部的最低花费
示例1:
输入 cost = [10, 15, 20]
输出: 15
从下标1开始爬, 向上2格. 到达楼梯顶部.
示例2:
输入：cost = [1,100,1,1,1,100,1,1,100,1] 输出：6 你将从下标为 0 的台阶开始。
支付 1 ，向上爬两个台阶，到达下标为 2 的台阶。 支付 1 ，向上爬两个台阶，到达下标为 4 的台阶。 支付 1 ，向上爬两个台阶，到达下标为 6 的台阶。 支付 1 ，向上爬一个台阶，到达下标为 7 的台阶。 支付 1 ，向上爬两个台阶，到达下标为 9 的台阶。 支付 1 ，向上爬一个台阶，到达楼梯顶部。 总花费为 6
删除并获取点数-LeetCode740
2022 年 04 月 13 日
题目描述 链接: https://leetcode-cn.com/problems/delete-and-earn/
给你一个整数数组nums, 可以对他进行一些操作. 每次操作中, 选择任意一个nums[i], 删除它然后获取nums[i]的点数. 同时还需要删除所有 等于nums[i]-1和nums[i]+1的元素. 例如删除3, 那么得到3个点数, 同时需要在数组中删除所有的2和4.
开始时拥有0个点数, 求你能通过这些操作获取的最大点数.
示例1:
输入: nums = [3, 4, 2]
输出: 6
删除4和2.得到6点.
删除4获取4个点数, 同时3也被删除.
还剩下2, 然后删除2再得到2个点数.
示例2:
输入: nums = [2, 2, 3, 3, 3, 4]
输出: 9
删除3, 总共可以得到9个点数(3*3). 同时删除2和4.
最终得到9个点数.
和为s的两个数组-LeetCode57
2022 年 04 月 13 日
题目描述 链接: https://leetcode-cn.com/problems/he-wei-sde-liang-ge-shu-zi-lcof/
输入一个递增排序的数组和一个数字s, 在数组中查找两个数, 使得它们的和正好是s, 如果有多对数字的和都等于s, 则输出任意一对即可. 示例1: 输入：nums = [2,7,11,15], target = 9 输出：[2,7] 或者 [7,2]
示例2: 输入：nums = [10,26,30,31,47,60], target = 40 输出：[10,30] 或者 [30,10]
翻转单词顺序-LeetCode58
2022 年 04 月 13 日
题目描述 链接: https://leetcode-cn.com/problems/fan-zhuan-dan-ci-shun-xu-lcof/
输入一个英文句子, 翻转句子中单词的顺序, 但单词内字符的顺序不变. 标点符号和普通字母一样处理. 例如输入字符串"I am a student.", 输出应该为"student. a am I"
示例1:
输入 : “the sky is blue”
输出 : “blue is sky the”
示例2:
输入 : " hello world! "
输出 : “world! hello”
忽略字符串前后的空格
示例3:
输入: “a good example”
输出: “example good a”
如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
打家劫舍2-LeetCode213
2022 年 04 月 13 日
题目描述 链接: https://leetcode-cn.com/problems/house-robber-ii/
你是一个专业的小偷, 计划偷窃沿街的房屋, 每间房内都藏有一定的现金. 这个地方所有的房屋都 围成一圈, 这意味着第一个房屋和最后一个房屋是紧挨着的. 同时, 相邻的房屋装有相互连通的防盗系统, 如果两间相邻的房屋在同一晚上被小偷闯入, 系统会自动报警 .
给定一个代表每个房屋存放金额的非负整数数组, 计算你在不触动警报装置的情况下,今晚能够偷窃到的最高金额.
示例1:
输入：nums = [2,3,2]
输出：3
你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
示例2:
输入：nums = [1,2,3,1]
输出：4
你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）. 偷窃到的最高金额 = 1 + 3 = 4 .
打家劫舍—LeetCode198
2022 年 04 月 13 日
题目描述 链接: https://leetcode-cn.com/problems/house-robber/
你是一个专业的小偷, 计划偷窃沿街的房屋, 每间房内都藏有一定的现金, 影响你偷窃的唯一限制因素是相邻的房屋装有相互连通的防盗系统. 如果两间相邻的房屋在同一晚上被小偷闯入, 系统会自动报警.
给定一个代表每个访问存放金额的非负整数数组, 计算你在不触发警报装置的情况下, 一夜之内能够偷窃到的最高金额.
示例1:
输入: [1, 2, 3, 1]
输出: 4
偷窃1号和3号. 得到1+3 = 4.
示例2:
输入: [2, 7, 9, 3, 1]
输出: 12
偷窃1号, 3号和5号. 得到2+9+1 = 12.
矩阵中的路径-剑指Offer LeetCode12
2022 年 03 月 25 日
题目描述 链接: https://leetcode-cn.com/problems/ju-zhen-zhong-de-lu-jing-lcof/
给定一个存储字母的m*n二维数组和一个字符串单词word. 如果word存在与二维数组中, 返回true, 否则返回flase
单词必须按照字母顺序, 通过相邻的单元格内的字母构成, 其他"相邻"单元格是那些水平相邻或垂直相邻的单元格. 同一个单元格内的字母不允许被重复使用.
例如, 在下面的3*4的矩阵中包含单词"ABCCED"
示例1:
输入: borad = [ [“A”, “B”, “C”, “E”], [“S”, “F”, “C”, “S”], [“A”, “D”, “E”, “E”], [“A”, “D”, “E”, “E”]], word = “ABCCED”
输出: true
示例2:
输入：board = [[“a”,“b”],[“c”,“d”]], word = “abcd” 输出：false
机器人的运动路径- 剑指Offer LeetCode13
2022 年 03 月 24 日
题目描述 链接: https://leetcode-cn.com/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof/
地上有一个m行n列的二维矩阵, 从坐标[0, 0]到[m-1, n-1]. 一个机器人从坐标[0, 0]的格子开始移动, 每次可以向左, 右, 上, 下移动一格.
不能移动到方格外, 也不能移动到行坐标和列坐标的数位之和大于K的格子. 例如当K=18时, 机器人可以进入方格[35, 37], 因为3+5+3+7=18. 但是不能进入[35, 38], 因为3+5+3+8=19. 求机器人能够到达多少个格子.
二叉树中和为某一值的路径- 剑指Offer LeetCode34
2022 年 03 月 24 日
题目描述 链接: https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/
给定二叉树的根节点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]]
有两条路径加起来之和等于22
示例2:
输入：root = [1,2,3], targetSum = 5 输出：[]
没有符合条件的路径
扑克牌中的顺子-剑指Offer LeetCode61
2022 年 03 月 23 日
题目描述 链接: https://leetcode-cn.com/problems/bu-ke-pai-zhong-de-shun-zi-lcof/
从若干幅扑克牌中随机抽5张牌, 判断是不是一个顺子, 即这五张牌是不是连续的. 2~10为数字本身, A为1, J为11, Q为12, K为13. 大小王为0, 并且可以看出任意数字
示例1:
输入: [1,2,3,4,5]
输出: true
示例2:
输入: [0,0,1,2,5]
输出: true. 由于两个0可以代替为3和4, 所以可以构成顺子
二叉搜索树的第K大节点-剑指Offer LeetCode54
2022 年 03 月 23 日
题目描述 链接: https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/
给定一颗二叉搜索树, 请找出其中第K大节点的值
示例1:
输入: 层序遍历 = [3, 1, 4, null ,2] , k = 1
3
/ \
1 4
\
2
输出: 4, 最大的节点为4
示例2:
输入: 层序遍历 = [ 5, 3, 6, 2, 4, null, null ,1], k = 3
5
/ \
3 6
/ \
2 4
/
1
输出: 4. 倒数第3个最大节点为4.
把数组排成最小的数-剑指Offer LeetCode45
2022 年 03 月 23 日
题目描述 链接: https://leetcode-cn.com/problems/ba-shu-zu-pai-cheng-zui-xiao-de-shu-lcof/
输入一个非负整数数组, 把数组里所有数字拼接起来排出一个数, 打印能拼接出的数字中最小的一个.
示例1:
输入: [10, 2]
输出: “102”. 两个数字的排列可能为102, 210. 由于102小, 所以结果为102.
示例2:
输入: [3, 30, 34, 5, 9]
输出: ”3033459“
2021
IPV4与Int的转换
2021 年 01 月 05 日
题目描述 将IPV4的地址转换成int值，然后再将其转换回来
2020
Z字形变换—LeetCode6
2020 年 07 月 02 日
题目描述 将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。
比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：
L C I R E T O E S I I G E D H N 之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如：“LCIRETOESIIGEDHN”。
请你实现这个将字符串进行指定行数变换的函数：
string convert(string s, int numRows); 示例 1:
输入: s = “LEETCODEISHIRING”, numRows = 3 输出: “LCIRETOESIIGEDHN” 示例 2:
输入: s = “LEETCODEISHIRING”, numRows = 4 输出: “LDREOEIIECIHNTSG” 解释:
L D R E O E I I E C I H N T S G
最小的k个数-LeetCodeM40
2020 年 04 月 13 日
题目描述 输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2 输出：[1,2] 或者 [2,1] 示例 2：
输入：arr = [0,1,2,1], k = 1 输出：[0]
限制：
0 <= k <= arr.length <= 10000 0 <= arr[i] <= 10000
给定一个数组，找出最小的k个数，对这k个数的大小顺序没有要求。
解题思路 这个题目我最开始的想法是用堆来解决的，但我解答完成看题解的时候发现了一种做法：
排序后取前k个元素
在评论区中有很多人在讨论这一种解法，虽然的他复杂度比较高，实现方式很简单，有一些专业人士在鄙视这种做法，也有一些人说这个题目的难度是简单，所以用这个也没什么问题。我的看法是支持这种做法，并不因为他的难度级别，而是解决问题的思路。在解决问题的时候每一种思路都是可取的。
二叉树的锯齿形层次遍历-LeetCode103
2020 年 03 月 31 日
题目描述 给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
例如： 给定二叉树 [3,9,20,null,null,15,7],
3 / \ 9 20 / \ 15 7 返回锯齿形层次遍历如下：
\[ \[3], \[20,9], \[15,7] ] 所谓的锯齿形遍历，即是在第一层从左向右遍历，在第二层从右向左遍历，依次遍历完成。
多数元素-LeetCode169
2020 年 03 月 29 日
题目描述 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1:
输入: [3,2,3] 输出: 3 示例 2:
输入: [2,2,1,1,1,2,2] 输出: 2
盛水最多的容器—LeetCode11
2020 年 03 月 26 日
题目描述 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
说明：你不能倾斜容器，且 n 的值至少为 2。
图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
示例：
输入：[1,8,6,2,5,4,8,3,7] 输出：49
有序链表转换为二叉搜索树—LeetCode109
2020 年 03 月 21 日
题目描述 给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例:
给定的有序链表： [-10, -3, 0, 5, 9],
一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：
0 -3 9 -10 5 答案不唯一，只要满足平常二叉树的特性即可。
题目中给出的数组已经按升序排序，我们需要将其转换为平衡二叉树。
统计位数为偶数的数字—LeetCode1295
2020 年 02 月 21 日
题目描述 给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。
示例 1：
输入：nums = [12,345,2,6,7896] 输出：2 解释： 12 是 2 位数字（位数为偶数） 345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数） 6 是 1 位数字 位数为奇数） 7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字 示例 2：
输入：nums = [555,901,482,1771] 输出：1 解释： 只有 1771 是位数为偶数的数字。
提示：
1 <= nums.length <= 500 1 <= nums[i] <= 10^5
二叉树的最大深度-LeetCode104
2020 年 02 月 20 日
题目描述 给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例： 给定二叉树 [3,9,20,null,null,15,7]，
3 / 9 20 / 15 7 返回它的最大深度 3 。
整数的各位积和之差—LeetCode1281
2020 年 02 月 19 日
题目描述 给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
示例 1：
输入：n = 234 输出：15 解释： 各位数之积 = 2 * 3 * 4 = 24 各位数之和 = 2 + 3 + 4 = 9 结果 = 24 - 9 = 15 示例 2：
输入：n = 4421 输出：21 解释： 各位数之积 = 4 * 4 * 2 * 1 = 32 各位数之和 = 4 + 4 + 2 + 1 = 11 结果 = 32 - 11 = 21
提示：
1 <= n <= 10^5
猜数字-LeetCodeLCP1
2020 年 02 月 14 日
题目描述 小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。
示例 1：
输入：guess = [1,2,3], answer = [1,2,3] 输出：3 解释：小A 每次都猜对了。
示例 2：
输入：guess = [2,2,3], answer = [3,2,1] 输出：1 解释：小A 只猜对了第二次。
限制：
guess的长度 = 3 answer的长度 = 3 guess的元素取值为 {1, 2, 3} 之一。 answer的元素取值为 {1, 2, 3} 之一。
链表中的倒数第K个节点-LeetCodeM22
2020 年 02 月 08 日
题目描述 输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
2019
环形链表—LeetCode141
2019 年 12 月 21 日
题目描述 给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
输入：head = \[3,2,0,-4], pos = 1 输出：true 解释：链表中有一个环，其尾部连接到第二个节点。 示例 2：
输入：head = \[1,2], pos = 0 输出：true 解释：链表中有一个环，其尾部连接到第一个节点。 示例 3：
输入：head = \[1], pos = -1 输出：false 解释：链表中没有环。 进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
移除元素-LeetCode27
2019 年 12 月 14 日
题目描述 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1:
给定 nums = [3,2,2,3], val = 3,
函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。
你不需要考虑数组中超出新长度后面的元素。 示例 2:
给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝 int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }
K个一组翻转链表-LeetCode25
2019 年 11 月 27 日
题目描述 给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。 k 是一个正整数，它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2->1->4->5 说明 : 你的算法只能使用常数的额外空间。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换
解题思路 首先根据 k，分隔每一组。将这一组反转，将下面的一组递归调用函数，然后将这一组的最后一个节点（就是参数中的头结点）与下一组反转后的头结点相连接。
用栈实现队列-LeetCode232
2019 年 11 月 24 日
题目描述 使用栈实现队列的下列操作：
push(x) – 将一个元素放入队列的尾部。 pop() – 从队列首部移除元素。 peek() – 返回队列首部的元素。 empty() – 返回队列是否为空。 示例:
MyQueue queue = new MyQueue();
queue.push(1); queue.push(2);
queue.peek(); // 返回 1 queue.pop(); // 返回 1 queue.empty(); // 返回 false 说明:
你只能使用标准的栈操作 – 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。 假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
解题思路 栈（先进后出）来实现队列（先进先出）。
可以用两个栈来实现，第一个栈存储，当进行 peek 或 pop 操作时，将第一个栈内元素按照先进后出的原则拿出来放到第二个栈里面。这时第二个栈里面在取就是我们总的第一个元素。
用队列实现栈-LeetCode225
2019 年 11 月 24 日
题目描述 使用队列实现栈的下列操作： push(x) – 元素 x 入栈 pop() – 移除栈顶元素 top() – 获取栈顶元素 empty() – 返回栈是否为空 注意:
你只能使用队列的基本操作– 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。 你所使用的语言也许不支持队列。 你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。 你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）。
解题思路 使用两个队列
将元素添加到第一个队列中。
在获取元素时，将第一个队列中除了最后一个元素都添加到第二个队列中，剩下的这个就是要返回的元素。
将两个队列进行交换，这样在添加元素时都能放到第一个队列中。
使用一个变量来存储最后一个元素，这样在调用 top 方法时直接返回这个变量即可。
使用一个队列
添加元素时添加到队列中，然后将队列中的元素除了最后一个再重新放入一遍
在获取元素和查看元素时都拿第一个即可
反转一个单链表-LeetCode206
2019 年 11 月 24 日
题目描述 反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
两两交换链表中的节点—LeetCode24
2019 年 11 月 21 日
题目描述 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3. 可以看出，链表每两个一组交换了前后位置，然后再跟其他元素按照原有顺序连接。
整数反转—LeetCode7
2019 年 11 月 15 日
题目描述 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
示例 1:
输入: 123 输出: 321 示例 2:
输入: -123 输出: -321 示例 3:
输入: 120 输出: 21 注意:
假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为 [−231, 231 − 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
题目中给出了条件，我们只能存储32位有符号整数，如果溢出后则返回0，避免出现溢出错误
回文数—LeetCode9
2019 年 11 月 07 日
题目描述 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121 输出: true 示例 2:
输入: -121 输出: false 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。 示例 3:
输入: 10 输出: false 解释: 从右向左读, 为 01 。因此它不是一个回文数。 进阶:
你能不将整数转为字符串来解决这个问题吗？
从示例2中可以看出，负数不是回文数，可以先对此进行判断。
而提示中有一个提示，能否不使用字符串来解决这个问题，那么使用字符串肯定是可以解决这个问题的。
翻转二叉树—LeetCode226
2019 年 11 月 01 日
二叉搜索树的范围和-LeetCode938
2019 年 10 月 31 日
题目描述 给定二叉搜索树的根结点 root，返回 L 和 R（含）之间的所有结点的值的和。
二叉搜索树保证具有唯一的值。
示例 1：
输入：root = [10,5,15,3,7,null,18], L = 7, R = 15 输出：32 示例 2：
输入：root = [10,5,15,3,7,13,18,1,null,6], L = 6, R = 10 输出：23
提示：
树中的结点数量最多为 10000 个。 最终的答案保证小于 2^31。
三数之和—LeetCode15
2019 年 10 月 25 日
题目描述 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？
请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：
给定数组 nums = [-1, 0, 1, 2, -1, -4]，
满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]
这个题目中有一个条件，答案中不可以包含重复的三元组，即给定的数组中会有重复值，所以答案可能会存在重复答案，当答案存在时，不在添加到答案中
实现strStr()—LeetCode28
2019 年 09 月 06 日
题目描述 实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1:
输入: haystack = “hello”, needle = “ll” 输出: 2 示例 2:
输入: haystack = “aaaaa”, needle = “bba” 输出: -1 说明:
当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。
两数相加-LeetCode2
2019 年 08 月 20 日
题目描述 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807
重复N次的元素-LeetCode961
2019 年 08 月 08 日
题目描述 在大小为 2N 的数组 A 中有 N+1 个不同的元素，其中有一个元素重复了 N 次。
返回重复了 N 次的那个元素。
示例 1：
输入：[1,2,3,3] 输出：3 示例 2：
输入：[2,1,2,5,3,2] 输出：2 示例 3：
输入：[5,1,5,2,5,3,5,4] 输出：5
提示：
4 <= A.length <= 10000 0 <= A[i] < 10000 A.length 为偶数
大小为2N的数字中有个N+1个元素，其中有个元素重复了N次，这也说明了除了这个元素其他元素都没有重复，也可以理解成查找重复的元素
有效的括号—LeetCode20
2019 年 08 月 07 日
题目描述 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 有效字符串需满足：
左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: "()" 输出: true 示例 2:
输入: "()[]{}" 输出: true 示例 3:
输入: "(]" 输出: false 示例 4:
输入: "(\[)]" 输出: false 示例 5:
输入: "{\[]}" 输出: true 这个题目与我们编译器对括号的识别一样，当我们多了一个括号后编译器会报错提示。
有效的括号—LeetCode20
2019 年 08 月 07 日
题目描述 给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = \[1,2,2,1], nums2 = \[2,2] 输出: \[2] 示例 2:
输入: nums1 = \[4,9,5], nums2 = \[9,4,9,8,4] 输出: \[9,4] 说明:
输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。
两个数组的交集II-LeetCode350
2019 年 08 月 07 日
题目描述 给定两个数组，编写一个函数来计算它们的交集。
示例 1:
输入: nums1 = \[1,2,2,1], nums2 = \[2,2] 输出: \[2,2] 示例 2:
输入: nums1 = \[4,9,5], nums2 = \[9,4,9,8,4] 输出: \[4,9] 说明：
输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。 我们可以不考虑输出结果的顺序。 *进阶:*
如果给定的数组已经排好序呢？你将如何优化你的算法？ 如果 nums1 的大小比 nums2 小很多，哪种方法更优？ 如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？ 这个题目的T349的进阶版。
保持城市的天际线-LeetCode807
2019 年 08 月 06 日
题目描述 在二维数组grid中，grid[i][j]代表位于某处的建筑物的高度。 我们被允许增加任何数量（不同建筑物的数量可能不同）的建筑物的高度。 高度 0 也被认为是建筑物。
最后，从新数组的所有四个方向（即顶部，底部，左侧和右侧）观看的“天际线”必须与原始数组的天际线相同。 城市的天际线是从远处观看时，由所有建筑物形成的矩形的外部轮廓。 请看下面的例子。
建筑物高度可以增加的最大总和是多少？
例子： 输入： grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]] 输出： 35 解释： The grid is: [ [3, 0, 8, 4], [2, 4, 5, 7], [9, 2, 6, 3], [0, 3, 1, 0] ]
从数组竖直方向（即顶部，底部）看“天际线”是：[9, 4, 8, 7] 从水平水平方向（即左侧，右侧）看“天际线”是：[8, 7, 9, 3]
在不影响天际线的情况下对建筑物进行增高后，新数组如下：
gridNew = [ [8, 4, 8, 7], [7, 4, 7, 7], [9, 4, 8, 7], [3, 3, 3, 3] ] 说明:
1 < grid.length = grid[0].length <= 50。 grid[i][j] 的高度范围是： [0, 100]。 一座建筑物占据一个grid[i][j]：换言之，它们是 1 x 1 x grid[i][j] 的长方体。
这个问题类似看三视图，然后再根据两个三视图合并出符合条件的最高值。
最后要返回的结果是这个最高值比原有值增长了多少
山脉数组的峰顶索引-LeetCode852
2019 年 07 月 18 日
题目描述 我们把符合下列属性的数组 A 称作山脉：
A.length >= 3 存在 0 < i < A.length - 1 使得A[0] < A[1] < … A[i-1] < A[i] > A[i+1] > … > A[A.length - 1] 给定一个确定为山脉的数组，返回任何满足 A[0] < A[1] < … A[i-1] < A[i] > A[i+1] > … > A[A.length - 1] 的 i 的值。
示例 1：
输入：[0,1,0] 输出：1 示例 2：
输入：[0,2,1,0] 输出：1
提示：
3 <= A.length <= 10000 0 <= A[i] <= 10^6 A 是如上定义的山脉
其实这就是一个寻找数组最大值的问题
键盘行-LeetCode500
2019 年 07 月 15 日
题目描述 给定一个单词列表，只返回可以使用在键盘同一行的字母打印出来的单词。键盘如下图所示。
示例：
输入: [“Hello”, “Alaska”, “Dad”, “Peace”] 输出: [“Alaska”, “Dad”]
注意：
你可以重复使用键盘上同一字符。 你可以假设输入的字符串将只包含字母。
判断给出的字符是否全部在一行中
反转字符串中的单词III-LeetCode557
2019 年 07 月 12 日
题目描述 给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
示例 1:
输入: “Let’s take LeetCode contest” 输出: “s’teL ekat edoCteeL tsetnoc” 注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
根据示例可以看出，需要将每个单词反转后再根据原有顺序拼接起来
反转字符串-LeetCode344
2019 年 07 月 10 日
删除最外层的括号—LeetCode1021
2019 年 06 月 22 日
题目描述： 有效括号字符串为空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。 例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括号字符串。 如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。 给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。 对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。 示例 1： 输入："(()())(())" 输出："()()()" 解释： 输入字符串为 “(()())(())"，原语化分解得到 “(()())” + “(())"， 删除每个部分中的最外层括号后得到 “()()” + “()” = “()()()"。 示例 2： 输入：”(()())(())(()(()))” 输出：”()()()()(())" 解释： 输入字符串为 “(()())(())(()(()))"，原语化分解得到 “(()())” + “(())” + “(()(()))"， 删除每隔部分中的最外层括号后得到 “()()” + “()” + “()(())” = “()()()()(())"。 示例 3： 输入：”()()” 输出：”" 解释： 输入字符串为 “()()"，原语化分解得到 “()” + “()"， 删除每个部分中的最外层括号后得到 "” + "” = “"。 提示： S.length <= 10000 S[i] 为 “(” 或 “)” S 是一个有效括号字符串
解题思路： 字符串S是一个有效括号字符串，那么我们可以先进行原语化分解，然后再对每个原语进行去除最外层括号。
进行原语分解的时候我们可以定义一个值和一个字符串，遇到左括号这个值加一并将左括号添加到这个字符串上，遇到右括号这个值减一并且将右括号添加到字符串上，当这个值变成0并且字符串的长度为2的倍数时就可以认为这个字符串是一个原语。
增减字符串匹配—LeetCode942
2019 年 06 月 20 日
高度检查器—LeetCode1051
2019 年 06 月 18 日
题目描述： 学校在拍年度纪念照时，一般要求学生按照 非递减 的高度顺序排列。 请你返回至少有多少个学生没有站在正确位置数量。该人数指的是：能让所有学生以 非递减 高度排列的必要移动人数。 示例： 输入：[1,1,4,2,1,3] 输出：3 解释： 高度为 4、3 和最后一个 1 的学生，没有站在正确的位置。 提示： 1 <= heights.length <= 100 1 <= heights[i] <= 100
三角形最小路径和—LeetCode120
2019 年 06 月 16 日
题目描述 给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
例如，给定三角形：
[ [2], [3,4], [6,5,7], [4,1,8,3] ] 自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。
说明：
如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。
题目中有一句话，每一步只能移动到下一行中相邻的结点中，所以在m行n列时，下一步的落地只能在m+1行n列或者m+1行n+1列中。
电话号码的字母组合—LeetCode17
2019 年 06 月 15 日
题目描述： 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例: 输入：“23” 输出：[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]. 说明: 尽管上面的答案是按字典序排列的，但是你可以任意选择答案输出的顺序。
题目解读： 这个问题的场景就是我们的手机9宫格按键，当我们按下按键时计算出所有的字母组合，当我们按下第一个按键时，现在的组合次数为该按键对应的字母个数(m)。当我们再一次按下一个按键时，现在的次数变成了这一次按键对应的字母个数与上一次的次数相乘(m*n)
反转图像—LeetCode832
2019 年 06 月 10 日
题目描述： 给定一个二进制矩阵 A，我们想先水平翻转图像，然后反转图像并返回结果。 水平翻转图片就是将图片的每一行都进行翻转，即逆序。例如，水平翻转 [1, 1, 0] 的结果是 [0, 1, 1]。 反转图片的意思是图片中的 0 全部被 1 替换， 1 全部被 0 替换。例如，反转 [0, 1, 1] 的结果是 [1, 0, 0]。 示例 1: 输入: [[1,1,0],[1,0,1],[0,0,0]] 输出:[[1,0,0],[0,1,0],[1,1,1]] 解释: 首先翻转每一行: [[0,1,1],[1,0,1],[0,0,0]]； 然后反转图片: [[1,0,0],[0,1,0],[1,1,1]] 示例 2: 输入: [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]] 输出: [[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]] 说明: 1 <= A.length = A[0].length <= 20 0 <= A[i][j] <= 1
解题思路： 将每一行进行翻转就是顺序转换，然后再进行反转图片就是将0转换为1，1转换为0，我们可以用 x=1-x来实现
自除数—LeetCode728
2019 年 06 月 04 日
题目描述： 自除数 是指可以被它包含的每一位数除尽的数。 例如，128 是一个自除数，因为 128 % 1 == 0，128 % 2 == 0，128 % 8 == 0。 还有，自除数不允许包含 0 。 给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。 示例 1： 输入： 上边界left = 1, 下边界right = 22 输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22] 注意： 每个输入参数的边界满足 1 <= left <= right <= 10000。
解读： 判断一个数能不能被他的每一位除尽，那就要取出每一位数，进行计算，并且自除数不允许包含0，所以如果有0则直接判断不是自除数
机器人能否返回终点—LeetCode657
2019 年 06 月 03 日
题目描述： 在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。 移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。 注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。 示例 1: 输入: “UD” 输出: true 解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。 示例 2: 输入: “LL” 输出: false 解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 “移动” 的距离。我们返回 false，因为它在移动结束时没有返回原点。
唯一摩尔斯密码词—LeetCode804
2019 年 06 月 02 日
题目描述： 国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: “a” 对应 “.-”, “b” 对应 “-…”, “c” 对应 “-.-.”, 等等。 为了方便，所有26个英文字母对应摩尔斯密码表如下： [".-","-…","-.-.","-..",".","..-.","–.","….","..",".—","-.-",".-..","–","-.","—",".–.","–.-",".-.","…","-","..-","…-",".–","-..-","-.–","–.."] 给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，“cab” 可以写成 “-.-..–…"，(即 “-.-.” + “-…” + “.-“字符串的结合)。我们将这样一个连接过程称作单词翻译。 返回我们可以获得所有词不同单词翻译的数量。 例如: 输入: words = [“gin”, “zen”, “gig”, “msg”] 输出: 2 解释: 各单词翻译如下: “gin” -> “–…-.” “zen” -> “–…-.” “gig” -> “–…–.” “msg” -> “–…–.” 共有 2 种不同翻译, “–…-.” 和 “–…–.”. 注意: 单词列表words 的长度不会超过 100。 每个单词 words[i]的长度范围为 [1, 12]。 每个单词 words[i]只包含小写字母。
解题思路： 我们首先要根据给出的单词转换成摩尔斯密码
利用一个数组按照字母顺序存储对应的密码值
将一个单词的每一个字母根据对应位数的摩尔斯密码进行转换然后拼接
这里利用set的不重复特性，将密码放入set集合中，如果有相同的密码则不会加入，最后获取set的长度即可。
Nim游戏—LeetCode292
2019 年 06 月 01 日
题目描述： 你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。 你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。 示例: 输入: 4 输出: false 解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛； 因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。 思路： 先考虑一下什么情况会输呢，就是最后的石头被对手拿走，那么只要保证最后剩余1-3块石头我们即可获胜。如何能确保最后一定剩余1-3块呢，就要我们在每一步的时候跟对手拿的块数总和等于4。所以我们这道题就可以判断总块数是不是4的倍数，如果不是我们就可以赢。
杨辉三角—LeetCode118
2019 年 05 月 05 日
题目描述 给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5 输出: [ [1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1] ]
只出现一次的数字—LeetCode136
2019 年 04 月 11 日
删除链表中的节点—LeetCode237
2019 年 04 月 07 日
题目描述 请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
示例 1:
输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9. 示例 2:
输入: head = [4,5,1,9], node = 1 输出: [4,5,9] 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明:
链表至少包含两个节点。 链表中所有节点的值都是唯一的。 给定的节点为非末尾节点并且一定是链表中的一个有效节点。 不要从你的函数中返回任何结果。
买卖股票的最佳时机II-LeetCode122
2019 年 03 月 18 日
题目描述 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4] 输出: 7 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 示例 2:
输入: [1,2,3,4,5] 输出: 4 解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 示例 3:
输入: [7,6,4,3,1] 输出: 0 解释: 在这种情况下, 没有交易完成, 所以最大利润为 0
题目中给出数组，第i个元素表示第i天的价格，我们要做的是求出能获取的最大利润，并且没有限制购买次数，我们可以第一天买入，最后一天卖出。也可以当天买入，第二天就卖出，然后再买入，再卖出。但是我们只能同时有一笔交易。
爬楼梯-LeetCode70
2019 年 03 月 16 日
题目描述 链接: https://leetcode-cn.com/problems/climbing-stairs/
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。问你有多少种不同的方法可以爬到楼顶？
示例 1：
输入： 2 输出： 2 有两种方法可以爬到楼顶。
第一种: 1 阶 + 1 阶
第二种: 2 阶
示例 2：
输入： 3
输出： 3
有三种方法可以爬到楼顶。
1 阶 + 1 阶 + 1 阶 1 阶 + 2 阶 2 阶 + 1 阶
无重复字符的最长子串-LeetCode3
2019 年 03 月 12 日
题目描述 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: “abcabcbb” 输出: 3 解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。 示例 2:
输入: “bbbbb” 输出: 1 解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。 示例 3:
输入: “pwwkew” 输出: 3 解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。 请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。
要注意这个题目最后要求返回的是长度，并不是最长的子串内容是什么
存在重复元素-LeetCode217
2019 年 03 月 10 日
题目描述 给定一个整数数组，判断是否存在重复元素。
如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
示例 1:
输入: [1,2,3,1] 输出: true 示例 2:
输入: [1,2,3,4] 输出: false 示例 3:
输入: [1,1,1,3,3,4,3,2,4,2] 输出: true
判断数组中是否有元素存在重复值。
搜索插入位置-LeetCode35
2019 年 03 月 06 日
题目描述 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5 输出: 2 示例 2:
输入: [1,3,5,6], 2 输出: 1 示例 3:
输入: [1,3,5,6], 7 输出: 4 示例 4:
输入: [1,3,5,6], 0 输出: 0
对称二叉树—LeetCode101
2019 年 02 月 25 日
题目描述 给定一个二叉树，检查它是否是镜像对称的。
例如，二叉树 [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 说明:
如果你可以运用递归和迭代两种方法解决这个问题，会很加分。
二进制链表转整数-LeetCode1290
2019 年 02 月 21 日
题目描述 给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的 十进制值 。
示例 1：
输入：head = \[1,0,1] 输出：5 解释：二进制数 (101) 转化为十进制数 (5) 示例 2：
输入：head = \[0] 输出：0 示例 3：
输入：head = \[1] 输出：1 示例 4：
输入：head = \[1,0,0,1,0,0,1,1,1,0,0,0,0,0,0] 输出：18880 示例 5：
输入：head = \[0,0] 输出：0 提示：
链表不为空。 链表的结点总数不超过 30。 每个结点的值不是 0 就是 1。
打印从1到最大的n位数—LeetCodeM17
2019 年 02 月 21 日
题目描述 输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
示例 1:
输入: n = 1 输出: \[1,2,3,4,5,6,7,8,9] 说明：
用返回一个整数列表来代替打印 n 为正整数 首先要获取最大值，然后遍历添加到数组中，而通过位数获取最大值可以通过10^n^来获取。
有序数组的平方—LeetCode977
2019 年 01 月 09 日
题目描述 给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
示例 1：
输入：[-4,-1,0,3,10] 输出：[0,1,9,16,100] 示例 2：
输入：[-7,-3,2,3,11] 输出：[4,9,9,49,121]
提示：
1 <= A.length <= 10000 -10000 <= A[i] <= 10000 A 已按非递减顺序排序。
最大二叉树—LeetCode654
2019 年 01 月 08 日
题目描述 给定一个不含重复元素的整数数组。一个以此数组构建的最大二叉树定义如下：
二叉树的根是数组中的最大元素。 左子树是通过数组中最大值左边部分构造出的最大二叉树。 右子树是通过数组中最大值右边部分构造出的最大二叉树。 通过给定的数组构建最大二叉树，并且输出这个树的根节点。
示例 ：
输入：[3,2,1,6,0,5] 输出：返回下面这棵树的根节点：
6 / \ 3 5 \ / 2 0 \ 1 提示：
给定的数组的大小在 [1, 1000] 之间。
按递增顺序显示卡牌—LeetCode950
2019 年 01 月 05 日
题目描述 牌组中的每张卡牌都对应有一个唯一的整数。你可以按你想要的顺序对这套卡片进行排序。
最初，这些卡牌在牌组里是正面朝下的（即，未显示状态）。
现在，重复执行以下步骤，直到显示所有卡牌为止：
从牌组顶部抽一张牌，显示它，然后将其从牌组中移出。 如果牌组中仍有牌，则将下一张处于牌组顶部的牌放在牌组的底部。 如果仍有未显示的牌，那么返回步骤 1。否则，停止行动。 返回能以递增顺序显示卡牌的牌组顺序。
答案中的第一张牌被认为处于牌堆顶部。
示例：
输入：[17,13,11,2,3,5,7] 输出：[2,13,3,11,5,17,7] 解释： 我们得到的牌组顺序为 [17,13,11,2,3,5,7]（这个顺序不重要），然后将其重新排序。 重新排序后，牌组以 [2,13,3,11,5,17,7] 开始，其中 2 位于牌组的顶部。 我们显示 2，然后将 13 移到底部。牌组现在是 [3,11,5,17,7,13]。 我们显示 3，并将 11 移到底部。牌组现在是 [5,17,7,13,11]。 我们显示 5，然后将 17 移到底部。牌组现在是 [7,13,11,17]。 我们显示 7，并将 13 移到底部。牌组现在是 [11,17,13]。 我们显示 11，然后将 17 移到底部。牌组现在是 [13,17]。 我们展示 13，然后将 17 移到底部。牌组现在是 [17]。 我们显示 17。 由于所有卡片都是按递增顺序排列显示的，所以答案是正确的。
提示：
1 <= A.length <= 1000 1 <= A[i] <= 10^6 对于所有的 i != j，A[i] != A[j]
x的平方根—LeetCode69
2019 年 01 月 05 日
题目描述 实现 int sqrt(int x) 函数。
计算并返回 x 的平方根，其中 x 是非负整数。
由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
示例 1:
输入: 4 输出: 2 示例 2:
输入: 8 输出: 2 说明: 8 的平方根是 2.82842…, 由于返回类型是整数，小数部分将被舍去。
转换为小写字母—LeetCode709
2019 年 01 月 03 日
题目描述 实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。
示例 1：
输入: “Hello” 输出: “hello” 示例 2：
输入: “here” 输出: “here” 示例 3：
输入: “LOVELY” 输出: “lovely”
按奇偶排序数组-LeetCode905
2019 年 01 月 02 日
题目描述 给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。
示例：
输入：[3,1,2,4] 输出：[2,4,3,1] 输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。
提示：
1 <= A.length <= 5000 0 <= A[i] <= 5000
2018
独特的电子邮件地址-LeetCode929
2018 年 12 月 21 日
题目描述 每封电子邮件都由一个本地名称和一个域名组成，以 @ 符号分隔。
例如，在 alice@leetcode.com中， alice 是本地名称，而 leetcode.com 是域名。
除了小写字母，这些电子邮件还可能包含 ‘.’ 或 ‘+’。
如果在电子邮件地址的本地名称部分中的某些字符之间添加句点（’.’），则发往那里的邮件将会转发到本地名称中没有点的同一地址。例如，“alice.z@leetcode.com” 和 “alicez@leetcode.com” 会转发到同一电子邮件地址。 （请注意，此规则不适用于域名。）
如果在本地名称中添加加号（’+’），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件，例如 m.y+name@email.com 将转发到 my@email.com。 （同样，此规则不适用于域名。）
可以同时使用这两个规则。
给定电子邮件列表 emails，我们会向列表中的每个地址发送一封电子邮件。实际收到邮件的不同地址有多少？
示例：
输入：[“test.email+alex@leetcode.com”,“test.e.mail+bob.cathy@leetcode.com”,“testemail+david@lee.tcode.com”] 输出：2 解释：实际收到邮件的是 “testemail@leetcode.com” 和 “testemail@lee.tcode.com”。
提示：
1 <= emails[i].length <= 100 1 <= emails.length <= 100 每封 emails[i] 都包含有且仅有一个 ‘@’ 字符。
最后一个单词的长度-LeetCode58
2018 年 12 月 20 日
题目描述 给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。
示例:
输入: “Hello World” 输出: 5
宝石与石头-LeetCode771
2018 年 12 月 19 日
题目描述 给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此"a"和"A"是不同类型的石头。
示例 1:
输入: J = “aA”, S = “aAAbbbb” 输出: 3 示例 2:
输入: J = “z”, S = “ZZ” 输出: 0 注意:
S 和 J 最多含有50个字母。 J 中的字符不重复。
最长公共前缀-LeetCode14
2018 年 12 月 12 日
题目描述 编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 ""。
示例 1:
输入: \["flower","flow","flight"] 输出: "fl" 示例 2:
输入: \["dog","racecar","car"] 输出: "" 解释: 输入不存在公共前缀。 说明:
所有输入只包含小写字母 a-z 。
罗马数字转整数-LeetCode13
2018 年 12 月 10 日
题目描述 罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值 I 1 V 5 X 10 L 50 C 100 D 500 M 1000 例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。 X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。 给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
示例 1:
输入: “III” 输出: 3 示例 2:
输入: “IV” 输出: 4 示例 3:
输入: “IX” 输出: 9 示例 4:
输入: “LVIII” 输出: 58 解释: L = 50, V= 5, III = 3. 示例 5:
输入: “MCMXCIV” 输出: 1994 解释: M = 1000, CM = 900, XC = 90, IV = 4.
删除排序数组中的重复项—LeetCode26
2018 年 09 月 10 日
题目描述 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
示例 1:
给定数组 nums = [1,1,2],
函数应该返回新的长度 2, 并且原数组 nums 的前两个元素被修改为 1, 2。
你不需要考虑数组中超出新长度后面的元素。 示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。
你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝 int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。 // 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。 for (int i = 0; i < len; i++) { print(nums[i]); }
这个题目有几个要求，原地算法，即不能使用额外的空间，空间复杂度要求O(1)。
同时我们不需要考虑数组中超出新长度后面的元素，实例1，我们最后给出的结果是[1,2,*]。第三个元素肯定是有的，不用对它进行重置等操作。
同时这个题，要求的返回结果是新的长度，即没有重复元素的个数。
旋转数组—LeetCode189
2018 年 08 月 29 日
加一—LeetCode66
2018 年 08 月 27 日
题目描述 给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1:
输入: [1,2,3] 输出: [1,2,4] 解释: 输入数组表示数字 123。 示例 2:
输入: [4,3,2,1] 输出: [4,3,2,2] 解释: 输入数组表示数字 4321。
一个数组，每一位表示一个数字，高位在前面，然后需要将这个值加一，并且按照数组的形式返回。
两数之和—LeetCode1
2018 年 08 月 25 日
题目描述 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9 所以返回 [0, 1]