2020年07月_知之为知

原创 1.栈的应用

/** * 栈的应用：括号匹配、表达式求值、递归 * 如：表达式求值：a+b-a*((c+d)/e-f)+g * 如：求斐波那契数列 0 1 1 2 3 5 8 13 ... */class Solution { // 1.递归(递归会用工作栈存储返回点、局部变量、传入参数) int Fib(int n) { if (n == 0) return 0; else if (n == 1) return 1; else return F

2020-07-31 15:00:11 466

原创 62.重复的子字符串-LeetCode-Java-待完善

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。示例 1:输入: "abab" 输出: True解释: 可由子字符串 "ab" 重复两次构成。示例 2:输入: "aba" 输出: False示例 3:输入: "abcabcabcabc" 输出: True解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)/** * 解法一：比如字符串"abcabcabcabc

2020-07-30 15:30:18 122

原创 61.分发饼干-LeetCode-Java

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。注意：你可以假设胃口值为正。胃口数组int[] g, 饼干数组int[] s,不一定是有序的。一个小朋友最多只能拥有一块饼干。示例

2020-07-29 14:22:05 110

原创 60.找到所有数组中消失的数字-LeetCode-Java

给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的整型数组，数组中的元素一些出现了两次，另一些只出现一次。找到所有在 [1, n] 范围之间没有出现在数组中的数字。您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。示例:输入:[4,3,2,7,8,2,3,1]输出:[5,6]/** * 常规思路：new int[n]做标记使用:空间复杂度O(n) * 原地操作:用原数组标记是否已经出现过:改变值为负则表

2020-07-28 21:40:42 149

原创 59. 字符串相加-LeetCode-Java

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。注意：num1 和num2 的长度都小于 5100.num1 和num2 都只包含数字 0-9.num1 和num2 都不包含任何前导零。你不能使用任何內建 BigInteger 库，也不能直接将输入的字符串转换为整数形式。/** * 方法一：依次位相加 * 将短的String添加"0"拼成一样长 */class Solution { public String addStrings(String num1

2020-07-26 14:29:22 115

原创 58.数字转换为十六进制数-LeetCode-Java

给定一个整数，编写一个算法将这个数转换为十六进制数。对于负整数，我们通常使用补码运算方法。注意:十六进制中所有字母(a-f)都必须是小写。十六进制字符串中不能包含多余的前导零。如果要转化的数为0，那么以单个字符'0'来表示；对于其他情况，十六进制字符串中的第一个字符将不会是0字符。给定的数确保在32位有符号整数范围内。不能使用任何由库提供的将数字直接转换或格式化为十六进制的方法。示例 1：输入:26 输出:"1a"示例 2：输入:-1 输出:"ffffffff"/** *

2020-07-25 15:18:20 1296

原创 57.左叶子之和-LeetCode-Java

计算给定二叉树的所有左叶子之和。示例： 3 / \ 9 20 / \ 15 7在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24//Definition for a binary tree node.class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; }}/

2020-07-24 11:49:10 88

原创 56.大小为 K 且平均值大于等于阈值的子数组数目-LeetCode-Java

给你一个整数数组 arr 和两个整数 k 和 threshold 。请你返回连续长度为 k 且平均值大于等于 threshold 的子数组数目。示例 1：输入：arr = [2,2,2,2,5,5,5,8], k = 3, threshold = 4输出：3解释：子数组 [2,5,5],[5,5,5] 和 [5,5,8] 的平均值分别为 4，5 和 6 。其他长度为 3 的子数组的平均值都小于 4 （threshold 的值)。示例 2：输入：arr = [1,1,1,1,1], k =

2020-07-23 11:30:58 151

原创 55.找不同-LeetCode-Java

给定两个字符串 s 和 t，它们只包含小写字母。字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。请找出在 t 中被添加的字母。示例:输入：s = "abcd"t = "abdec"输出：e解释：'e' 是那个被添加的字母。和"43.缺失数字"一个思路/** * 方法一：找单身狗 */class Solution { public char findTheDifference(String s, String t) { int i;

2020-07-22 14:30:19 164

原创 54.有效的完全平方数-LeetCode-Java

给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 True，否则返回 False。示例 1：输入：16 输出：True示例 2：输入：14 输出：False/** * 方法一：使用平方根库函数 */class Solution { public boolean isPerfectSquare(int num) { return Math.sqrt(num) % 1 == 0 ? true : false; }}/**

2020-07-21 11:38:22 110

原创 53.两个数组的交集 II-LeetCode-Java

给定两个数组，编写一个函数来计算它们的交集。示例 1：输入：nums1 = [1,2,2,1], nums2 = [2,2]输出：[2,2]示例 2:输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]输出：[4,9] 说明：输出结果中每个元素出现的次数，应与元素在两个数组中出现次数的最小值一致。我们可以不考虑输出结果的顺序。import java.util.ArrayList;import java.util.HashMap;class Solu

2020-07-21 10:35:56 83

原创选择排序-简单选择排序

public class SelectSort { /** * 每一趟定位选择最小的元素到前面 */ public void sort(int[] A) { for (int i = 0; i < A.length; i++) { int min = i; for (int j = i + 1; j < A.length; j++) { if (A[min] &gt

2020-07-20 22:05:41 96

原创交换排序-快速排序

public class QuickSort { public void Quicksort(int[] A, int low, int high) { if (low < high) { int pivotPos = Partition(A, low, high); Quicksort(A, low, pivotPos - 1); Quicksort(A, pivotPos + 1, high);

2020-07-20 22:03:20 88

原创交换排序-冒泡排序

public class BubbleSort { /** * 每一趟遍历交换一个最小的元素到最终位置 */ public void sort(int[] A) { for (int i = 0; i < A.length - 1; i++) { for (int j = i + 1; j <= A.length - 1; j++) { if (A[i] > A[j]) {

2020-07-20 21:14:59 98

原创插入排序-希尔排序

public class ShellSort { public void sort(int[] A) { int i, j, k; for (int dk = A.length / 2; dk >= 1; dk = dk / 2) { for (i = 0; i < dk; i++) { for (j = i + dk; j < A.length; j += dk) {

2020-07-20 18:11:31 91

原创插入排序-折半插入排序

package Sort;/** * 折半插入排序：当序列是连续存储时，对直接插入排序进行的改进：插入位置可以更快速找到 * 直接插入排序A[0]用作哨兵减少条件判断，折半插入排序不需要哨兵A[0]位置存放实际元素 */public class InsertSort { public void sort(int[] A) { int temp; int i, j, low, high, mid; for (i = 1; i < A

2020-07-20 16:19:48 113

原创插入排序-直接插入排序

/** * 直接插入排序有 “哨兵”情况 A[0]位置不存放元素作为 ”哨兵“ * 初始有序队列为A[1],依次将A[2]~A[n]插入到有序队列中 */public class InsertSort { public void sort(int[] A) { int i, j; for (i = 2; i < A.length; i++) { if (A[i] < A[i - 1]) {

2020-07-20 15:19:47 285

原创 52.两个数组的交集-LeetCode-Java

给定两个数组，编写一个函数来计算它们的交集。示例 1：输入：nums1 = [1,2,2,1], nums2 = [2,2]输出：[2]示例 2：输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]输出：[9,4] 说明：输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。import java.util.Arrays;import java.util.HashSet;/** * 使用HashSet */class Solution

2020-07-20 12:06:19 85 1

原创 51.反转字符串中的元音字母-LeetCode-Java

编写一个函数，以字符串作为输入，反转该字符串中的元音字母。示例 1:输入: "hello"输出: "holle"示例 2:输入: "leetcode"输出: "leotcede"说明:元音字母包含字母"aeiouAEIOU"。class Solution { public static final HashSet<Character> set = new HashSet<Character>(Arrays.asList('a', 'A', 'e', '

2020-07-20 11:10:00 127

原创 50.3的幂-LeetCode-Java

给定一个整数，写一个函数来判断它是否是 3 的幂次方。示例 1:输入: 0 输出: false示例 2:输入: 1 输出: true示例 3:输入: 27 输出: true示例 4:输入: 45 输出: false/** * 方法一：递归 */class Solution { public boolean isPowerOfThree(int n) { if (n == 3 || n == 1) return true; if (n

2020-07-19 09:24:30 94

原创 49.区域和检索 - 数组不可变-LeetCode-Java

给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。示例：给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()sumRange(0, 2) -> 1sumRange(2, 5) -> -1sumRange(0, 5) -> -3说明:你可以假设数组不可变。会多次调用 sumRange 方法(成千上万次调用)/** * 方法一：常规方法 * 每次调用s

2020-07-18 10:02:36 67

原创 48.猜数字游戏-LeetCode-Java

你在和朋友一起玩猜数字（Bulls and Cows）游戏，该游戏规则如下：你写出一个秘密数字，并请朋友猜这个数字是多少。朋友每猜测一次，你就会给他一个提示，告诉他的猜测数字中有多少位属于数字和确切位置都猜对了（称为“Bulls”, 公牛），有多少位属于数字猜对了但是位置不对（称为“Cows”, 奶牛）。朋友根据提示继续猜，直到猜出秘密数字。请写出一个根据秘密数字和朋友的猜测数返回提示的函数，返回字符串的格式为 xAyB ，x 和 y 都是数字，A 表示公牛，用 B 表示奶牛。xA 表示有

2020-07-17 13:00:49 308

原创 47.Nim 游戏-LeetCode-Java

你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。拿掉最后一块石头的人就是获胜者。你作为先手。你们是聪明人，每一步都是最优解。编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。示例:输入: 4 输出: false 解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；因为无论你拿走 1 块、2 块还是 3 块石头，最后一块石头总是会被你的朋友拿走。/** * 如果是n=9，我要数到1，5，9稳赢 * 我：1

2020-07-16 11:08:07 105

原创 46.单词规律-LeetCode-Java

给定一种规律 pattern 和一个字符串 str ，判断 str 是否遵循相同的规律。这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 str 中的每个非空单词之间存在着双向连接的对应规律。示例1:输入: pattern = "abba", str = "dog cat cat dog"输出: true示例 2:输入:pattern = "abba", str = "dog cat cat fish"输出: false示例 3:输入: pattern = "a

2020-07-15 08:11:48 102

原创 45.移动零-LeetCode-Java

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序(非0元素原次序不变)示例:输入: [0,4,0,3,12]输出: [4,3,12,0,0]说明:必须在原数组上操作，不能拷贝额外的数组。尽量减少操作次数。/** * 方法一： * i指针遍历找到所有值为0位置 * j在i后面找非0元素替换 */class Solution { public void moveZeroes(int[] nums) { for (i

2020-07-14 08:46:52 69

原创 44.第一个错误的版本-LeetCode-Java

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。示例:给定 n = 5，并且

2020-07-13 09:27:15 103

原创 43.缺失数字-LeetCode-Java

给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。示例 1:输入: [3,0,1] 输出: 2示例 2:输入: [9,6,4,2,3,5,7,0,1] 输出: 8 说明:你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?/** * 方法一：使用一个等长的数组 * 同样这里数组可以换成hash表 * 空间复杂度O(n) */ class Solution { public int missin

2020-07-12 13:56:01 181

原创 42.丑数-LeetCode-Java

编写一个程序判断给定的数是否为丑数。丑数就是只包含质因数 2, 3, 5 的正整数。示例 1:输入: 6 输出: true解释: 6 = 2 × 3示例 2:输入: 8 输出: true解释: 8 = 2 × 2 × 2示例 3:输入: 14 输出: false 解释: 14 不是丑数，因为它包含了另外一个质因数 7。说明：1 是丑数。输入不会超过 32 位有符号整数的范围: [−231, 231 − 1]。/** * 方法一：循环整除后看结果是否是 2, 3, 5

2020-07-12 11:28:08 132

原创 41.各位相加-LeetCode-Java

给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。示例:输入: 38 输出: 2 解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。由于 2 是一位数，所以返回 2。进阶:你可以不使用循环或者递归，且在 O(1) 时间复杂度内解决这个问题吗？// 方法一：递归class Solution { public int addDigits(int num) { int sum = 0; while (num != 0)

2020-07-11 22:17:16 119

原创 40.二叉树的所有路径-LeetCode-Java

给定一个二叉树，返回所有从根节点到叶子节点的路径。说明: 叶子节点是指没有子节点的节点。示例:输入: 1 / \2 3 \ 5输出: ["1->2->5", "1->3"]解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3/** * 先序遍历(深度优先遍历 DFS) 访问所有路径 * 思考：这里path使用String类型,可不可以使用StringBuilder */class Solution {

2020-07-11 08:03:53 130

原创 39.按奇偶排序数组 II-LeetCode-Java

给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。你可以返回任何满足上述条件的数组作为答案。示例：输入：[4,2,5,7]输出：[4,5,2,7]解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。提示：2 <= A.length <= 20000A.length % 2 == 00 <= A[i] <= 1000/

2020-07-10 21:10:13 108

原创 38.旋转数组-LeetCode-Java

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。示例 1:输入: [1,2,3,4,5,6,7] 和 k = 3输出: [5,6,7,1,2,3,4]解释:向右旋转 1 步: [7,1,2,3,4,5,6]向右旋转 2 步: [6,7,1,2,3,4,5]向右旋转 3 步: [5,6,7,1,2,3,4]示例 2:输入: [-1,-100,3,99] 和 k = 2输出: [3,99,-1,-100]解释: 向右旋转 1 步: [99,-1,-100,3]

2020-07-08 21:56:45 166

原创 37.阶乘后的零-LeetCode-Java

给定一个整数 n，返回 n! 结果尾数中零的数量。示例 1:输入: 3 输出: 0解释: 3! = 6, 尾数中没有零。示例 2:输入: 5 输出: 1解释: 5! = 120, 尾数中有 1 个零.说明: 你算法的时间复杂度应为 O(log n) /** * 30!>Long.MAX_VALUE 不能使用long * 使用float、double精度又会有所损失. * 固如下方法不可使用. * 需要一个大整数乘法计算(不丢失精度) */class Solution

2020-07-07 10:41:17 157

原创 36.Excel表列序号-LeetCode-Java

给定一个Excel表格中的列名称，返回其相应的列序号。例如， A -> 1 B -> 2 C -> 3 ... Z -> 26 AA -> 27 AB -> 28 ... 示例 1: 输入: "A" 输出: 1示例 2: 输入: "AB" 输出: 28示例 3: 输入: "ZY" 输出: 701/** * ASCII码 A~Z(65~90) */class Solution {

2020-07-06 22:09:32 79

原创 35.多数元素-LeetCode-Java

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。示例 1:输入: [3,2,3] 输出: 3示例 2:输入: [2,2,1,1,1,2,2] 输出: 2示例 3:输入: [1] 输出: 1/** * 方法一：hash */class Solution { public int majorityElement(int[] nums) { int

2020-07-06 14:01:29 178

原创 34.Excel表列名称-LeetCode-Java

给定一个正整数，返回它在 Excel 表中相对应的列名称。例如， 1 -> A 2 -> B 3 -> C ... 26 -> Z 27 -> AA 28 -> AB ... 示例 1:输入: 1输出: "A"示例 2:输入: 28输出: "AB"示例 3:输入: 701输出: "ZY"/** * ASCII码A~Z(65~90) * Excel A~Z(1~26)

2020-07-06 10:12:41 72

原创 33.两数之和 II - 输入有序数组-LeetCode-Java

给定一个已按照升序排列的有序数组，找到两个数使得它们相加之和等于目标数。函数应该返回这两个下标值 index1 和 index2，其中 index1 必须小于 index2。说明:返回的下标值（index1 和 index2）不是从零开始的。你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。示例:输入: numbers = [2, 7, 11, 17], target = 19输出: [1,4]解释: 2 与 17 之和等于目标数 19 。因此 index1 = 1,

2020-07-05 22:47:17 78

原创 32.判断路径是否相交-LeetCode-Java

给你一个字符串 path，其中 path[i] 的值可以是 'N'、'S'、'E' 或者 'W'，分别表示向北、向南、向东、向西移动一个单位。机器人从二维平面上的原点 (0, 0) 处开始出发，按 path 所指示的路径行走。如果路径在任何位置上出现相交的情况，也就是走到之前已经走过的位置，请返回 True ；否则，返回 False 。示例 1：输入：path = "NES"输出：false 解释：该路径没有在任何位置相交。示例 2：输入：path = "NESWW"输出：true解

2020-07-05 12:02:34 1008

原创 31.相交链表-LeetCode-Java

编写一个程序，找到两个单链表相交的起始节点。示例 1：输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3输出：Reference of the node with value = 8输入解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2

2020-07-05 10:25:22 70

原创 30.最小栈-LeetCode-Java

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。push(x) —— 将元素 x 推入栈中。pop() —— 删除栈顶的元素。top() —— 获取栈顶元素。getMin() —— 检索栈中的最小元素。示例:输入：["MinStack","push","push","push","getMin","pop","top","getMin"][[],[-2],[0],[-3],[],[],[],[]]输出：[null,null,null,null

2020-07-05 09:08:37 88

空空如也

空空如也