stack = new Stack<>();
9 | int ans = 0;
10 |
11 | for (int i = 0; i < height.length; i++) {
12 | // 维持最小栈
13 | while (!stack.empty() && height[i] > height[stack.peek()]) {
14 | int pop = stack.pop();
15 | // 此时栈为空，说明左边没有柱子，一定接不住雨水
16 | if (stack.empty()) {
17 | break;
18 | }
19 |
20 | int left = stack.peek();
21 | int s = i - left - 1;
22 | // 高度：左、右柱子的最低高度减去底边柱子
23 | int h = Math.min(height[i], height[left]) - height[pop];
24 | ans += s * h;
25 | }
26 | stack.push(i);
27 | }
28 | return ans;
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code516_LongestPalindromicSubsequence.md:
--------------------------------------------------------------------------------
1 | 给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。
2 |
3 | 子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：s = "bbbab"
11 | 输出：4
12 | 解释：一个可能的最长回文子序列为 "bbbb" 。
13 |
14 |
15 | 示例 2：
16 |
17 |
18 | 输入：s = "cbbd"
19 | 输出：2
20 | 解释：一个可能的最长回文子序列为 "bb" 。
21 |
22 |
23 |
24 |
25 | 提示：
26 |
27 |
28 | 1 <= s.length <= 1000s 仅由小写英文字母组成
31 |
👍 717👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code77_Combinations.md:
--------------------------------------------------------------------------------
1 | 给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。
2 |
3 | 你可以按 任何顺序 返回答案。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：n = 4, k = 2
11 | 输出：
12 | [
13 | [2,4],
14 | [3,4],
15 | [2,3],
16 | [1,2],
17 | [1,3],
18 | [1,4],
19 | ]
20 |
21 | 示例 2：
22 |
23 |
24 | 输入：n = 1, k = 1
25 | 输出：[[1]]
26 |
27 |
28 |
29 | 提示：
30 |
31 |
32 | 1 <= n <= 201 <= k <= n
35 |
👍 781👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/geektime/week_00/Solution142.java:
--------------------------------------------------------------------------------
1 | package com.data.geektime.week_00;
2 |
3 | import com.data.entity.ListNode;
4 |
5 | // 环形链表 II 找到入环节点
6 | public class Solution142 {
7 |
8 | // 从相遇点到入环点的距离加上 n−1 圈的环长，恰好等于从链表头部到入环点的距离。
9 | public ListNode detectCycle(ListNode head) {
10 | // 双指针一开始都在head
11 | ListNode fast = head, slow = head;
12 |
13 | while (fast != null && fast.next != null) {
14 | // 快指针一次跑2补，慢指针一次跑一步
15 | fast = fast.next.next;
16 | slow = slow.next;
17 |
18 | // 第一次在环中相遇
19 | if (slow == fast) {
20 | // 重置fast为head
21 | fast = head;
22 | while (fast != slow) {
23 | fast = fast.next;
24 | slow = slow.next;
25 | }
26 | // 第二次相遇时即是入环节点
27 | return fast;
28 | }
29 | }
30 | return null;
31 | }
32 | }
33 |
34 |
--------------------------------------------------------------------------------
/note/clickhouse/1docker快速安装clickhouse.md:
--------------------------------------------------------------------------------
1 | - 创建docker-compose.yml
2 |
3 | ```yaml
4 | version: '3'
5 |
6 | services:
7 | ch_server:
8 | image: yandex/clickhouse-server
9 | ports:
10 | - "8123:8123"
11 | volumes:
12 | - ./db:/var/lib/clickhouse
13 | networks:
14 | - ch_ntw
15 |
16 | ch_client:
17 | image: yandex/clickhouse-client
18 | entrypoint:
19 | - /bin/sleep
20 | command:
21 | - infinity
22 | networks:
23 | - ch_ntw
24 |
25 | networks:
26 | ch_ntw:
27 | driver: bridge
28 | ipam:
29 | config:
30 | - subnet: 10.222.1.0/24
31 | ```
32 |
33 | - 启动clickhouse服务
34 |
35 | ```
36 | docker-compose up -d
37 | ```
38 |
39 | - 进入clickhouse客户端
40 |
41 | ```
42 | docker-compose exec ch_server clickhouse-client
43 | ```
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code416_PartitionEqualSubsetSum.md:
--------------------------------------------------------------------------------
1 | 给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：nums = [1,5,11,5]
9 | 输出：true
10 | 解释：数组可以分割成 [1, 5, 5] 和 [11] 。
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：nums = [1,2,3,5]
16 | 输出：false
17 | 解释：数组不能分割成两个元素和相等的子集。
18 |
19 |
20 |
21 |
22 | 提示：
23 |
24 |
25 | 1 <= nums.length <= 2001 <= nums[i] <= 100
28 |
👍 1115👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 44_ShuZiXuLieZhongMouYiWeiDeShuZiLcof.md:
--------------------------------------------------------------------------------
1 | 数字以0123456789101112131415…的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。
2 |
3 | 请写一个函数，求任意第n位对应的数字。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 | 输入：n = 3
10 | 输出：3
11 |
12 |
13 | 示例 2：
14 |
15 | 输入：n = 11
16 | 输出：0
17 |
18 |
19 |
20 | 限制：
21 |
22 |
25 |
26 | 注意：本题与主站 400 题相同：https://leetcode-cn.com/problems/nth-digit/
27 |
👍 182👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code96_UniqueBinarySearchTrees.md:
--------------------------------------------------------------------------------
1 | 给你一个整数 n ，求恰由 n 个节点组成且节点值从 1 到 n 互不相同的 二叉搜索树 有多少种？返回满足题意的二叉搜索树的种数。
2 |
3 |
4 |
5 | 示例 1：
6 | 
7 |
8 | 输入：n = 3
9 | 输出：5
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：n = 1
16 | 输出：1
17 |
18 |
19 |
20 |
21 | 提示：
22 |
23 |
26 | Related Topics
树二叉搜索树数学动态规划二叉树
👍 1426👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 32 - II_CongShangDaoXiaDaYinErChaShuIiLcof.md:
--------------------------------------------------------------------------------
1 | 从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
2 |
3 |
4 |
5 | 例如:
6 | 给定二叉树: [3,9,20,null,null,15,7],
7 |
8 | 3
9 | / \
10 | 9 20
11 | / \
12 | 15 7
13 |
14 |
15 | 返回其层次遍历结果：
16 |
17 | [
18 | [3],
19 | [9,20],
20 | [15,7]
21 | ]
22 |
23 |
24 |
25 |
26 | 提示：
27 |
28 |
29 | 节点总数 <= 1000
31 |
32 | 注意：本题与主站 102 题相同：https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
33 |
👍 160👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 33_ErChaSouSuoShuDeHouXuBianLiXuLieLcof.md:
--------------------------------------------------------------------------------
1 | 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
2 |
3 |
4 |
5 | 参考以下这颗二叉搜索树：
6 |
7 | 5
8 | / \
9 | 2 6
10 | / \
11 | 1 3
12 |
13 | 示例 1：
14 |
15 | 输入: [1,6,3,2,5]
16 | 输出: false
17 |
18 | 示例 2：
19 |
20 | 输入: [1,3,2,6,5]
21 | 输出: true
22 |
23 |
24 |
25 | 提示：
26 |
27 |
28 | 数组长度 <= 1000
30 | Related Topics
栈树二叉搜索树递归二叉树单调栈
👍 382👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 43_OneNzhengShuZhong1chuXianDeCiShuLcof.md:
--------------------------------------------------------------------------------
1 | 输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。
2 |
3 | 例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：n = 12
11 | 输出：5
12 |
13 |
14 | 示例 2：
15 |
16 |
17 | 输入：n = 13
18 | 输出：6
19 |
20 |
21 |
22 | 限制：
23 |
24 |
27 |
28 | 注意：本题与主站 233 题相同：https://leetcode-cn.com/problems/number-of-digit-one/
29 |
👍 250👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution70.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | // 排序数组中只出现一次的数字
4 | public class Solution70 {
5 |
6 | // 给定一个只包含整数的有序数组 nums ，每个元素都会出现两次，唯有一个数只会出现一次，请找出这个唯一的数字。
7 | public int singleNonDuplicate(int[] nums) {
8 | // 将数组每两个分为一组，如果有一个数只出现一次，那么会导致当前以及后面的组的数字都不一样
9 | int left = 0;
10 | int right = nums.length / 2;
11 |
12 | while (left <= right) {
13 | int mid = (left + right) / 2;
14 | int i = 2 * mid;
15 |
16 | if (i < nums.length - 1 && nums[i] != nums[i + 1]) { // 此时i位置是出现了组内元素不一致的组
17 | if (i == 0 || nums[i - 1] == nums[i - 2]) { // 是第一个组
18 | return nums[i];
19 | }
20 | // 不是第一个组
21 | right = mid - 1;
22 | } else {
23 | left = mid + 1;
24 | }
25 | }
26 | // 前面寻找的组不包括数组的最后一个元素
27 | return nums[nums.length - 1];
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code70_ClimbingStairs.md:
--------------------------------------------------------------------------------
1 | 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
2 |
3 | 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：n = 2
11 | 输出：2
12 | 解释：有两种方法可以爬到楼顶。
13 | 1. 1 阶 + 1 阶
14 | 2. 2 阶
15 |
16 | 示例 2：
17 |
18 |
19 | 输入：n = 3
20 | 输出：3
21 | 解释：有三种方法可以爬到楼顶。
22 | 1. 1 阶 + 1 阶 + 1 阶
23 | 2. 1 阶 + 2 阶
24 | 3. 2 阶 + 1 阶
25 |
26 |
27 |
28 |
29 | 提示：
30 |
31 |
34 | Related Topics
记忆化搜索数学动态规划
👍 2150👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 30_BaoHanMinhanShuDeZhanLcof.md:
--------------------------------------------------------------------------------
1 | 定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。
2 |
3 |
4 |
5 | 示例:
6 |
7 | MinStack minStack = new MinStack();
8 | minStack.push(-2);
9 | minStack.push(0);
10 | minStack.push(-3);
11 | minStack.min(); --> 返回 -3.
12 | minStack.pop();
13 | minStack.top(); --> 返回 0.
14 | minStack.min(); --> 返回 -2.
15 |
16 |
17 |
18 |
19 | 提示：
20 |
21 |
22 | - 各函数的调用总次数不超过 20000 次
23 |
24 |
25 |
26 |
27 | 注意：本题与主站 155 题相同：https://leetcode-cn.com/problems/min-stack/
28 |
👍 235👎 0
--------------------------------------------------------------------------------
/akka/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 | bigdata
7 | groupId
8 | 1.0-SNAPSHOT
9 |
10 | 4.0.0
11 |
12 | akka
13 |
14 |
15 | 8
16 | 8
17 |
18 |
19 |
20 |
21 | com.typesafe.akka
22 | akka-actor_2.11
23 | 2.3.6
24 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 42_LianXuZiShuZuDeZuiDaHeLcof.md:
--------------------------------------------------------------------------------
1 | 输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
2 |
3 | 要求时间复杂度为O(n)。
4 |
5 |
6 |
7 | 示例1:
8 |
9 | 输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
10 | 输出: 6
11 | 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
12 |
13 |
14 |
15 | 提示：
16 |
17 |
18 | 1 <= arr.length <= 10^5-100 <= arr[i] <= 100
21 |
22 | 注意：本题与主站 53 题相同：https://leetcode-cn.com/problems/maximum-subarray/
23 |
24 |
25 |
👍 425👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code560_SubarraySumEqualsK.md:
--------------------------------------------------------------------------------
1 | 给你一个整数数组 nums 和一个整数 k ，请你统计并返回该数组中和为 k 的连续子数组的个数。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：nums = [1,1,1], k = 2
9 | 输出：2
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：nums = [1,2,3], k = 3
16 | 输出：2
17 |
18 |
19 |
20 |
21 | 提示：
22 |
23 |
24 | 1 <= nums.length <= 2 * 104-1000 <= nums[i] <= 1000-107 <= k <= 107
28 |
👍 1300👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 45_BaShuZuPaiChengZuiXiaoDeShuLcof.md:
--------------------------------------------------------------------------------
1 | 输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。
2 |
3 |
4 |
5 | 示例 1:
6 |
7 | 输入: [10,2]
8 | 输出: "102"
9 |
10 | 示例 2:
11 |
12 | 输入: [3,30,34,5,9]
13 | 输出: "3033459"
14 |
15 |
16 |
17 | 提示:
18 |
19 |
20 | 0 < nums.length <= 100
22 |
23 | 说明:
24 |
25 |
26 | - 输出结果可能非常大，所以你需要返回一个字符串而不是整数
27 | - 拼接起来的数字可能会有前导 0，最后结果不需要去掉前导 0
28 |
29 |
👍 330👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code78_Subsets.md:
--------------------------------------------------------------------------------
1 | 给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
2 |
3 | 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：nums = [1,2,3]
11 | 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
12 |
13 |
14 | 示例 2：
15 |
16 |
17 | 输入：nums = [0]
18 | 输出：[[],[0]]
19 |
20 |
21 |
22 |
23 | 提示：
24 |
25 |
26 | 1 <= nums.length <= 10-10 <= nums[i] <= 10nums 中的所有元素 互不相同
30 |
👍 1396👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 10- I_FeiBoNaQiShuLieLcof.md:
--------------------------------------------------------------------------------
1 | 写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：
2 |
3 |
4 | F(0) = 0, F(1) = 1
5 | F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
6 |
7 | 斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
8 |
9 | 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
10 |
11 |
12 |
13 | 示例 1：
14 |
15 |
16 | 输入：n = 2
17 | 输出：1
18 |
19 |
20 | 示例 2：
21 |
22 |
23 | 输入：n = 5
24 | 输出：5
25 |
26 |
27 |
28 |
29 | 提示：
30 |
31 |
34 | Related Topics
记忆化搜索数学动态规划
👍 263👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 13_JiQiRenDeYunDongFanWeiLcof.md:
--------------------------------------------------------------------------------
1 | 地上有一个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。请问该机器人能够到达多少个格子？
2 |
3 |
4 |
5 | 示例 1：
6 |
7 | 输入：m = 2, n = 3, k = 1
8 | 输出：3
9 |
10 |
11 | 示例 2：
12 |
13 | 输入：m = 3, n = 1, k = 0
14 | 输出：1
15 |
16 |
17 | 提示：
18 |
19 |
20 | 1 <= n,m <= 1000 <= k <= 20
23 | Related Topics
深度优先搜索广度优先搜索动态规划
👍 392👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 17_DaYinCong1daoZuiDaDeNweiShuLcof.java:
--------------------------------------------------------------------------------
1 | //输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
2 | //
3 | // 示例 1:
4 | //
5 | // 输入: n = 1
6 | //输出: [1,2,3,4,5,6,7,8,9]
7 | //
8 | //
9 | //
10 | //
11 | // 说明：
12 | //
13 | //
14 | // 用返回一个整数列表来代替打印
15 | // n 为正整数
16 | //
17 | // Related Topics 数组 数学 👍 163 👎 0
18 |
19 | package leetcode.editor.cn;
20 | // 剑指 Offer 17.打印从1到最大的n位数
21 | class Code_Offer_DaYinCong1daoZuiDaDeNweiShuLcof {
22 | //leetcode submit region begin(Prohibit modification and deletion)
23 | class Solution {
24 | public int[] printNumbers(int n) {
25 | int end = (int)Math.pow(10, n) - 1;
26 | int[] res = new int[end];
27 | for(int i = 0; i < end; i++)
28 | res[i] = i + 1;
29 | return res;
30 |
31 | }
32 | }
33 | //leetcode submit region end(Prohibit modification and deletion)
34 |
35 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 11_XuanZhuanShuZuDeZuiXiaoShuZiLcof.md:
--------------------------------------------------------------------------------
1 | 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
2 |
3 | 给你一个可能存在 重复 元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为1。
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：[3,4,5,1,2]
9 | 输出：1
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：[2,2,2,0,1]
16 | 输出：0
17 |
18 |
19 | 注意：本题与主站 154 题相同：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/
20 |
👍 453👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution80.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.LinkedList;
4 | import java.util.List;
5 |
6 | // 包含k个元素的组合
7 | public class Solution80 {
8 |
9 | public List> combine(int n, int k) {
10 | List> ans = new LinkedList<>();
11 | LinkedList subset = new LinkedList<>();
12 |
13 | // 在数字[1...n]中选出k和数，从1开始
14 | dfs(n, k, 1, ans, subset);
15 | return ans;
16 | }
17 |
18 | private void dfs(int n, int k, int index, List> ans, LinkedList subset) {
19 | // base case
20 | if (subset.size() == k) {
21 | ans.add(new LinkedList<>(subset));
22 | } else if (index <= n) {
23 | // 不要当前元素
24 | dfs(n, k, index + 1, ans, subset);
25 |
26 | // 要当前元素
27 | subset.add(index);
28 | dfs(n, k, index + 1, ans, subset);
29 | subset.removeLast();
30 | }
31 | }
32 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code69_Sqrtx.md:
--------------------------------------------------------------------------------
1 | 给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
2 |
3 | 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
4 |
5 | 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：x = 4
13 | 输出：2
14 |
15 |
16 | 示例 2：
17 |
18 |
19 | 输入：x = 8
20 | 输出：2
21 | 解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
22 |
23 |
24 |
25 |
26 | 提示：
27 |
28 |
29 | 0 <= x <= 231 - 1
31 |
👍 879👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code876_MiddleOfTheLinkedList.md:
--------------------------------------------------------------------------------
1 | 给定一个头结点为 head 的非空单链表，返回链表的中间结点。
2 |
3 | 如果有两个中间结点，则返回第二个中间结点。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：[1,2,3,4,5]
11 | 输出：此列表中的结点 3 (序列化形式：[3,4,5])
12 | 返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。
13 | 注意，我们返回了一个 ListNode 类型的对象 ans，这样：
14 | ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = NULL.
15 |
16 |
17 | 示例 2：
18 |
19 |
20 | 输入：[1,2,3,4,5,6]
21 | 输出：此列表中的结点 4 (序列化形式：[4,5,6])
22 | 由于该列表有两个中间结点，值分别为 3 和 4，我们返回第二个结点。
23 |
24 |
25 |
26 |
27 | 提示：
28 |
29 |
30 | - 给定链表的结点数介于
1 和 100 之间。
31 |
32 |
👍 448👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code111_MinimumDepthOfBinaryTree.md:
--------------------------------------------------------------------------------
1 | 给定一个二叉树，找出其最小深度。
2 |
3 | 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
4 |
5 | 说明：叶子节点是指没有子节点的节点。
6 |
7 |
8 |
9 | 示例 1：
10 | 
11 |
12 | 输入：root = [3,9,20,null,null,15,7]
13 | 输出：2
14 |
15 |
16 | 示例 2：
17 |
18 |
19 | 输入：root = [2,null,3,null,4,null,5,null,6]
20 | 输出：5
21 |
22 |
23 |
24 |
25 | 提示：
26 |
27 |
28 | - 树中节点数的范围在
[0, 105] 内
29 | -1000 <= Node.val <= 1000
31 | Related Topics
树深度优先搜索广度优先搜索二叉树
👍 625👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 29_ShunShiZhenDaYinJuZhenLcof.md:
--------------------------------------------------------------------------------
1 | 输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 | 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
8 | 输出：[1,2,3,6,9,8,7,4,5]
9 |
10 |
11 | 示例 2：
12 |
13 | 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
14 | 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
15 |
16 |
17 |
18 |
19 | 限制：
20 |
21 |
22 | 0 <= matrix.length <= 1000 <= matrix[i].length <= 100
25 |
26 | 注意：本题与主站 54 题相同：https://leetcode-cn.com/problems/spiral-matrix/
27 |
👍 319👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution41.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.LinkedList;
4 | import java.util.Queue;
5 |
6 | // 滑动窗口的平均值
7 | public class Solution41 {
8 |
9 | Queue nums;
10 | int capacity;
11 | int sum;
12 |
13 | public Solution41(int size) {
14 | nums = new LinkedList<>();
15 | capacity = size;
16 | }
17 |
18 | // 添加一个元素，并返回平均值
19 | public double next(int val) {
20 | nums.offer(val);
21 | sum += val;
22 |
23 | if (nums.size() > capacity) {
24 | sum -= nums.poll();
25 | }
26 | return (double) sum / nums.size();
27 | }
28 |
29 | public static void main(String[] args) {
30 | Solution41 solution = new Solution41(3);
31 | System.out.println(solution.next(1));
32 | System.out.println(solution.next(2));
33 | System.out.println(solution.next(3));
34 | System.out.println(solution.next(4));
35 | System.out.println(solution.next(111));
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 18_ShanChuLianBiaoDeJieDianLcof.md:
--------------------------------------------------------------------------------
1 | 给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
2 |
3 | 返回删除后的链表的头节点。
4 |
5 | 注意：此题对比原题有改动
6 |
7 | 示例 1:
8 |
9 | 输入: head = [4,5,1,9], val = 5
10 | 输出: [4,1,9]
11 | 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
12 |
13 |
14 | 示例 2:
15 |
16 | 输入: head = [4,5,1,9], val = 1
17 | 输出: [4,5,9]
18 | 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
19 |
20 |
21 |
22 |
23 | 说明：
24 |
25 |
26 | - 题目保证链表中节点的值互不相同
27 | - 若使用 C 或 C++ 语言，你不需要
free 或 delete 被删除的节点
28 |
29 |
👍 169👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/geektime/week_00/Solution20.java:
--------------------------------------------------------------------------------
1 | package com.data.geektime.week_00;
2 |
3 | import java.util.HashMap;
4 | import java.util.Stack;
5 |
6 | // 有效的括号 ()[]{}
7 | public class Solution20 {
8 |
9 | public boolean isValid(String s) {
10 | if (s == null || s.length() == 0 || s.length() % 2 != 0) {
11 | return false;
12 | }
13 |
14 | HashMap map = new HashMap<>();
15 | map.put(')', '(');
16 | map.put(']', '[');
17 | map.put('}', '{');
18 |
19 | Stack stack = new Stack<>();
20 |
21 | for (int i = 0; i < s.length(); i++) {
22 | char ch = s.charAt(i);
23 | // 每当遇到一个右括号，就去看栈顶中是否是左括号
24 | if (map.containsKey(ch)) {
25 | if (stack.empty() || stack.peek() != map.get(ch)) {
26 | return false;
27 | }
28 | stack.pop();
29 | } else { // 遍历到的是一个左括号，则加入到栈中
30 | stack.push(ch);
31 | }
32 | }
33 | return stack.empty();
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code55_JumpGame.md:
--------------------------------------------------------------------------------
1 | 给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
2 |
3 | 数组中的每个元素代表你在该位置可以跳跃的最大长度。
4 |
5 | 判断你是否能够到达最后一个下标。
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：nums = [2,3,1,1,4]
13 | 输出：true
14 | 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
15 |
16 |
17 | 示例 2：
18 |
19 |
20 | 输入：nums = [3,2,1,0,4]
21 | 输出：false
22 | 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
23 |
24 |
25 |
26 |
27 | 提示：
28 |
29 |
30 | 1 <= nums.length <= 3 * 1040 <= nums[i] <= 105
33 |
👍 1502👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 10- II_QingWaTiaoTaiJieWenTiLcof.md:
--------------------------------------------------------------------------------
1 | 一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
2 |
3 | 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
4 |
5 | 示例 1：
6 |
7 | 输入：n = 2
8 | 输出：2
9 |
10 |
11 | 示例 2：
12 |
13 | 输入：n = 7
14 | 输出：21
15 |
16 |
17 | 示例 3：
18 |
19 | 输入：n = 0
20 | 输出：1
21 |
22 | 提示：
23 |
24 |
27 |
28 | 注意：本题与主站 70 题相同：https://leetcode-cn.com/problems/climbing-stairs/
29 |
30 |
31 | Related Topics
记忆化搜索数学动态规划
👍 216👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 33_ErChaSouSuoShuDeHouXuBianLiXuLieLcof.java:
--------------------------------------------------------------------------------
1 | //输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
2 | //
3 | //
4 | //
5 | // 参考以下这颗二叉搜索树：
6 | //
7 | // 5
8 | // / \
9 | // 2 6
10 | // / \
11 | // 1 3
12 | //
13 | // 示例 1：
14 | //
15 | // 输入: [1,6,3,2,5]
16 | //输出: false
17 | //
18 | // 示例 2：
19 | //
20 | // 输入: [1,3,2,6,5]
21 | //输出: true
22 | //
23 | //
24 | //
25 | // 提示：
26 | //
27 | //
28 | // 数组长度 <= 1000
29 | //
30 | // Related Topics 栈 树 二叉搜索树 递归 二叉树 单调栈 👍 382 👎 0
31 |
32 | package leetcode.editor.cn;
33 |
34 | // 剑指 Offer 33.二叉搜索树的后序遍历序列
35 | class Code_Offer_ErChaSouSuoShuDeHouXuBianLiXuLieLcof {
36 |
37 | //leetcode submit region begin(Prohibit modification and deletion)
38 | class Solution {
39 |
40 | public boolean verifyPostorder(int[] postorder) {
41 | return false;
42 |
43 | }
44 | }
45 | //leetcode submit region end(Prohibit modification and deletion)
46 |
47 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code46_Permutations.md:
--------------------------------------------------------------------------------
1 | 给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：nums = [1,2,3]
9 | 输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：nums = [0,1]
16 | 输出：[[0,1],[1,0]]
17 |
18 |
19 | 示例 3：
20 |
21 |
22 | 输入：nums = [1]
23 | 输出：[[1]]
24 |
25 |
26 |
27 |
28 | 提示：
29 |
30 |
31 | 1 <= nums.length <= 6-10 <= nums[i] <= 10nums 中的所有整数 互不相同
35 |
👍 1657👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/geektime/week_01/Solution239.java:
--------------------------------------------------------------------------------
1 | package com.data.geektime.week_01;
2 |
3 | import java.util.LinkedList;
4 |
5 | // 滑动窗口最大值
6 | public class Solution239 {
7 |
8 | public int[] maxSlidingWindow(int[] nums, int k) {
9 | if (nums == null || k < 1 || nums.length < k) {
10 | return null;
11 | }
12 | // qmax 窗口最大值的更新结构
13 | // 放下标
14 | LinkedList qmax = new LinkedList();
15 | int[] res = new int[nums.length - k + 1];
16 | int index = 0;
17 | // 遍历数组：每前进一次就是一个窗口
18 | for (int R = 0; R < nums.length; R++) {
19 | while (!qmax.isEmpty() && nums[qmax.peekLast()] <= nums[R]) {
20 | qmax.pollLast();
21 | }
22 | qmax.addLast(R);
23 | // 移除过期的下标
24 | if (qmax.peekFirst() == R - k) {
25 | qmax.pollFirst();
26 | }
27 | // 是否形成一个有效的窗口
28 | if (R >= k - 1) {
29 | res[index++] = nums[qmax.peekFirst()];
30 | }
31 | }
32 | return res;
33 | }
34 |
35 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 26_ShuDeZiJieGouLcof.md:
--------------------------------------------------------------------------------
1 | 输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
2 |
3 | B是A的子结构， 即 A中有出现和B相同的结构和节点值。
4 |
5 | 例如:
6 | 给定的树 A:
7 |
8 | 3
9 | / \
10 | 4 5
11 | / \
12 | 1 2
13 | 给定的树 B：
14 |
15 | 4
16 | /
17 | 1
18 | 返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
19 |
20 | 示例 1：
21 |
22 | 输入：A = [1,2,3], B = [3,1]
23 | 输出：false
24 |
25 |
26 | 示例 2：
27 |
28 | 输入：A = [3,4,5,1,2], B = [4,1]
29 | 输出：true
30 |
31 | 限制：
32 |
33 | 0 <= 节点个数 <= 10000
34 |
👍 403👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer II 009_ZVAVXX.java:
--------------------------------------------------------------------------------
1 | /**
2 | * English description is not available for the problem. Please switch to Chinese.
3 | *
👍 39👎 0
4 | */
5 | package leetcode.editor.cn;
6 |
7 | // 剑指 Offer II 009.乘积小于 K 的子数组
8 | class Code_Offer_ZVAVXX {
9 |
10 | //leetcode submit region begin(Prohibit modification and deletion)
11 | class Solution {
12 |
13 | // 双指针，left和right之间维持乘积小于k
14 | public int numSubarrayProductLessThanK(int[] nums, int k) {
15 | int p1 = 0;
16 | int sum = 1;
17 | int count = 0;
18 |
19 | for (int p2 = 0; p2 < nums.length; p2++) {
20 | sum *= nums[p2];
21 | while (p1 <= p2 && sum >= k) {
22 | sum /= nums[p1++];
23 | }
24 | count += p2 - p1 + 1;
25 | }
26 | return count;
27 | }
28 | }
29 | //leetcode submit region end(Prohibit modification and deletion)
30 |
31 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code5_LongestPalindromicSubstring.md:
--------------------------------------------------------------------------------
1 | 给你一个字符串 s，找到 s 中最长的回文子串。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：s = "babad"
9 | 输出："bab"
10 | 解释："aba" 同样是符合题意的答案。
11 |
12 |
13 | 示例 2：
14 |
15 |
16 | 输入：s = "cbbd"
17 | 输出："bb"
18 |
19 |
20 | 示例 3：
21 |
22 |
23 | 输入：s = "a"
24 | 输出："a"
25 |
26 |
27 | 示例 4：
28 |
29 |
30 | 输入：s = "ac"
31 | 输出："a"
32 |
33 |
34 |
35 |
36 | 提示：
37 |
38 |
39 | 1 <= s.length <= 1000s 仅由数字和英文字母（大写和/或小写）组成
42 |
👍 4372👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code84_LargestRectangleInHistogram.md:
--------------------------------------------------------------------------------
1 | 给定 n 个非负整数，用来表示柱状图中各个柱子的高度。每个柱子彼此相邻，且宽度为 1 。
2 |
3 | 求在该柱状图中，能够勾勒出来的矩形的最大面积。
4 |
5 |
6 |
7 | 示例 1:
8 |
9 | 
10 |
11 |
12 | 输入：heights = [2,1,5,6,2,3]
13 | 输出：10
14 | 解释：最大的矩形为图中红色区域，面积为 10
15 |
16 |
17 | 示例 2：
18 |
19 | 
20 |
21 |
22 | 输入： heights = [2,4]
23 | 输出： 4
24 |
25 |
26 |
27 | 提示：
28 |
29 |
30 | 1 <= heights.length <=1050 <= heights[i] <= 104
33 |
👍 1741👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 14- I_JianShengZiLcof.md:
--------------------------------------------------------------------------------
1 | 给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
2 |
3 | 示例 1：
4 |
5 | 输入: 2
6 | 输出: 1
7 | 解释: 2 = 1 + 1, 1 × 1 = 1
8 |
9 | 示例 2:
10 |
11 | 输入: 10
12 | 输出: 36
13 | 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
14 |
15 | 提示：
16 |
17 |
20 |
21 | 注意：本题与主站 343 题相同：https://leetcode-cn.com/problems/integer-break/
22 |
👍 326👎 0
--------------------------------------------------------------------------------
/spark/src/main/resources/log4j.properties:
--------------------------------------------------------------------------------
1 | log4j.rootCategory=WARN, console
2 | log4j.appender.console=org.apache.log4j.ConsoleAppender
3 | log4j.appender.console.target=System.err
4 | log4j.appender.console.layout=org.apache.log4j.PatternLayout
5 | log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n
6 |
7 | # Set the default spark-shell log level to WARN. When running the spark-shell, the
8 | # log level for this class is used to overwrite the root logger's log level, so that
9 | # the user can have different defaults for the shell and regular Spark apps.
10 | log4j.logger.org.apache.spark.repl.Main=WARN
11 |
12 | # Settings to quiet third party logs that are too verbose
13 | log4j.logger.org.spark_project.jetty=WARN
14 | log4j.logger.org.spark_project.jetty.util.component.AbstractLifeCycle=ERROR
15 | log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=INFO
16 | log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=INFO
17 | log4j.logger.org.apache.parquet=ERROR
18 | log4j.logger.parquet=ERROR
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 39_ShuZuZhongChuXianCiShuChaoGuoYiBanDeShuZiLcof.java:
--------------------------------------------------------------------------------
1 | //数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
2 | //
3 | //
4 | //
5 | // 你可以假设数组是非空的，并且给定的数组总是存在多数元素。
6 | //
7 | //
8 | //
9 | // 示例 1:
10 | //
11 | // 输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
12 | //输出: 2
13 | //
14 | //
15 | //
16 | // 限制：
17 | //
18 | // 1 <= 数组长度 <= 50000
19 | //
20 | //
21 | //
22 | // 注意：本题与主站 169 题相同：https://leetcode-cn.com/problems/majority-element/
23 | //
24 | //
25 | // Related Topics 数组 哈希表 分治 计数 排序 👍 220 👎 0
26 |
27 | package leetcode.editor.cn;
28 |
29 | import java.util.Arrays;
30 |
31 | // 剑指 Offer 39.数组中出现次数超过一半的数字
32 | class Code_Offer_ShuZuZhongChuXianCiShuChaoGuoYiBanDeShuZiLcof {
33 |
34 | //leetcode submit region begin(Prohibit modification and deletion)
35 | class Solution {
36 |
37 | public int majorityElement(int[] nums) {
38 | Arrays.sort(nums);
39 | return nums[nums.length / 2];
40 |
41 | }
42 | }
43 | //leetcode submit region end(Prohibit modification and deletion)
44 |
45 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code61_RotateList.md:
--------------------------------------------------------------------------------
1 | 给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。
2 |
3 |
4 |
5 | 示例 1：
6 | 
7 |
8 | 输入：head = [1,2,3,4,5], k = 2
9 | 输出：[4,5,1,2,3]
10 |
11 |
12 | 示例 2：
13 | 
14 |
15 | 输入：head = [0,1,2], k = 4
16 | 输出：[2,0,1]
17 |
18 |
19 |
20 |
21 | 提示：
22 |
23 |
24 | - 链表中节点的数目在范围
[0, 500] 内
25 | -100 <= Node.val <= 1000 <= k <= 2 * 109
28 |
👍 662👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/geektime/week_01/Solution84.java:
--------------------------------------------------------------------------------
1 | package com.data.geektime.week_01;
2 |
3 | import java.util.Stack;
4 |
5 | // 柱状图中最大矩形
6 | public class Solution84 {
7 |
8 | public int largestRectangleArea(int[] heights) {
9 |
10 | // 固定一个高，向左右两边扩展，知道遇到矮的柱子，因为位置维持一个递增栈
11 | Stack stack = new Stack<>();
12 | int maxArea = 0;
13 |
14 | for (int i = 0; i < heights.length; i++) {
15 | while (!stack.empty() && heights[i] < heights[stack.peek()]) { // 当前柱子比栈顶低
16 | int pop = stack.pop(); // 栈顶元素
17 | int left = !stack.empty() ? stack.peek() : -1;
18 | int area = (i - left - 1) * heights[pop];
19 | maxArea = Math.max(maxArea, area);
20 | }
21 | stack.push(i);
22 | }
23 |
24 | while (!stack.empty()) {
25 | int pop = stack.pop(); // 栈顶元素
26 | int left = !stack.empty() ? stack.peek() : -1;
27 | int area = (heights.length - left - 1) * heights[pop];
28 | maxArea = Math.max(maxArea, area);
29 | }
30 | return maxArea;
31 | }
32 | }
33 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code15_ThreeSum.md:
--------------------------------------------------------------------------------
1 | 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
2 |
3 | 注意：答案中不可以包含重复的三元组。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：nums = [-1,0,1,2,-1,-4]
11 | 输出：[[-1,-1,2],[-1,0,1]]
12 |
13 |
14 | 示例 2：
15 |
16 |
17 | 输入：nums = []
18 | 输出：[]
19 |
20 |
21 | 示例 3：
22 |
23 |
24 | 输入：nums = [0]
25 | 输出：[]
26 |
27 |
28 |
29 |
30 | 提示：
31 |
32 |
33 | 0 <= nums.length <= 3000-105 <= nums[i] <= 105
36 |
👍 4010👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code617_MergeTwoBinaryTrees.md:
--------------------------------------------------------------------------------
1 | 给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。
2 |
3 | 你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。
4 |
5 | 示例 1:
6 |
7 |
8 | 输入:
9 | Tree 1 Tree 2
10 | 1 2
11 | / \ / \
12 | 3 2 1 3
13 | / \ \
14 | 5 4 7
15 | 输出:
16 | 合并后的树:
17 | 3
18 | / \
19 | 4 5
20 | / \ \
21 | 5 4 7
22 |
23 |
24 | 注意: 合并必须从两个树的根节点开始。
25 | Related Topics
树深度优先搜索广度优先搜索二叉树
👍 816👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code83_RemoveDuplicatesFromSortedList.md:
--------------------------------------------------------------------------------
1 | 存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。
2 |
3 | 返回同样按升序排列的结果链表。
4 |
5 |
6 |
7 | 示例 1：
8 | 
9 |
10 | 输入：head = [1,1,2]
11 | 输出：[1,2]
12 |
13 |
14 | 示例 2：
15 | 
16 |
17 | 输入：head = [1,1,2,3,3]
18 | 输出：[1,2,3]
19 |
20 |
21 |
22 |
23 | 提示：
24 |
25 |
26 | - 链表中节点数目在范围
[0, 300] 内
27 | -100 <= Node.val <= 100- 题目数据保证链表已经按升序排列
29 |
30 |
👍 679👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution14.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | // 剑指 Offer II 014. 字符串中的变位词
4 | public class Solution14 {
5 |
6 | // s2中是否包含s1的变位词
7 | public boolean checkInclusion(String s1, String s2) {
8 | if (s1.length() > s2.length()) {
9 | return false;
10 | }
11 |
12 | int[] counts = new int[26];
13 | for (int i = 0; i < s1.length(); i++) {
14 | counts[s1.charAt(i) - 'a']++;
15 | counts[s2.charAt(i) - 'a']--;
16 | }
17 |
18 | if (check(counts)) {
19 | return true;
20 | }
21 |
22 | for (int i = s1.length(); i < s2.length(); i++) {
23 | counts[s2.charAt(i) - 'a']--;
24 | counts[s2.charAt(i - s1.length()) - 'a']++;
25 |
26 | if (check(counts)) {
27 | return true;
28 | }
29 | }
30 | return false;
31 | }
32 |
33 | private boolean check(int[] counts) {
34 | for (int count : counts) {
35 | if (count != 0) {
36 | return false;
37 | }
38 | }
39 | return true;
40 | }
41 |
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer II 010_QTMn0o.java:
--------------------------------------------------------------------------------
1 | /**
2 | * English description is not available for the problem. Please switch to Chinese.
3 | *
👍 38👎 0
4 | */
5 | package leetcode.editor.cn;
6 |
7 | import java.util.HashMap;
8 |
9 | // 剑指 Offer II 010.和为 k 的子数组
10 | class Code_Offer_QTMn0o {
11 |
12 | //leetcode submit region begin(Prohibit modification and deletion)
13 | class Solution {
14 |
15 | // 前缀和:map存前缀和以及次数
16 | public int subarraySum(int[] nums, int k) {
17 | HashMap map = new HashMap<>();
18 | map.put(0, 1);
19 |
20 | int sum = 0, count = 0;
21 |
22 | for (int num : nums) {
23 | sum += num;
24 | count += map.getOrDefault(sum - k, 0);
25 | map.put(sum, map.getOrDefault(sum, 0) + 1);
26 | }
27 | return count;
28 | }
29 | }
30 | //leetcode submit region end(Prohibit modification and deletion)
31 |
32 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code198_HouseRobber.md:
--------------------------------------------------------------------------------
1 | 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
2 |
3 | 给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：[1,2,3,1]
11 | 输出：4
12 | 解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
13 | 偷窃到的最高金额 = 1 + 3 = 4 。
14 |
15 | 示例 2：
16 |
17 |
18 | 输入：[2,7,9,3,1]
19 | 输出：12
20 | 解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
21 | 偷窃到的最高金额 = 2 + 9 + 1 = 12 。
22 |
23 |
24 |
25 |
26 | 提示：
27 |
28 |
29 | 1 <= nums.length <= 1000 <= nums[i] <= 400
32 |
👍 1859👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code199_BinaryTreeRightSideView.md:
--------------------------------------------------------------------------------
1 | 给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
2 |
3 |
4 |
5 | 示例 1:
6 |
7 | 
8 |
9 |
10 | 输入: [1,2,3,null,5,null,4]
11 | 输出: [1,3,4]
12 |
13 |
14 | 示例 2:
15 |
16 |
17 | 输入: [1,null,3]
18 | 输出: [1,3]
19 |
20 |
21 | 示例 3:
22 |
23 |
24 | 输入: []
25 | 输出: []
26 |
27 |
28 |
29 |
30 | 提示:
31 |
32 |
33 | - 二叉树的节点个数的范围是
[0,100]
34 | -100 <= Node.val <= 100
36 | Related Topics
树深度优先搜索广度优先搜索二叉树
👍 573👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution48.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import com.data.entity.TreeNode;
4 |
5 | // 序列化与反序列化二叉树
6 | public class Solution48 {
7 |
8 | // 先序遍历序列化
9 | public String serialize(TreeNode root) {
10 | if (root == null) {
11 | return "#";
12 | }
13 | String leftSer = serialize(root.left);
14 | String rightSer = serialize(root.right);
15 | // 拼接
16 | return root.val + "," + leftSer + "," + rightSer;
17 | }
18 |
19 | // 先序遍历反序列化
20 | public TreeNode deserialize(String data) {
21 | String[] nodeStrs = data.split(",");
22 | int[] i = {0};
23 | return dfs(nodeStrs, i);
24 | }
25 |
26 | private TreeNode dfs(String[] nodeStrs, int[] i) {
27 | String nodeStr = nodeStrs[i[0]];
28 | i[0]++;
29 |
30 | if ("#".equals(nodeStr)) {
31 | return null;
32 | }
33 |
34 | TreeNode node = new TreeNode(Integer.parseInt(nodeStr));
35 | node.left = dfs(nodeStrs, i);
36 | node.right = dfs(nodeStrs, i);
37 |
38 | return node;
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code66_PlusOne.md:
--------------------------------------------------------------------------------
1 | 给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
2 |
3 | 最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
4 |
5 | 你可以假设除了整数 0 之外，这个整数不会以零开头。
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：digits = [1,2,3]
13 | 输出：[1,2,4]
14 | 解释：输入数组表示数字 123。
15 |
16 |
17 | 示例 2：
18 |
19 |
20 | 输入：digits = [4,3,2,1]
21 | 输出：[4,3,2,2]
22 | 解释：输入数组表示数字 4321。
23 |
24 |
25 | 示例 3：
26 |
27 |
28 | 输入：digits = [0]
29 | 输出：[1]
30 |
31 |
32 |
33 |
34 | 提示：
35 |
36 |
37 | 1 <= digits.length <= 1000 <= digits[i] <= 9
40 |
👍 914👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code86_PartitionList.md:
--------------------------------------------------------------------------------
1 | 给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。
2 |
3 | 你应当 保留 两个分区中每个节点的初始相对位置。
4 |
5 |
6 |
7 | 示例 1：
8 | 
9 |
10 | 输入：head = [1,4,3,2,5,2], x = 3
11 | 输出：[1,2,2,4,3,5]
12 |
13 |
14 | 示例 2：
15 |
16 |
17 | 输入：head = [2,1], x = 2
18 | 输出：[1,2]
19 |
20 |
21 |
22 |
23 | 提示：
24 |
25 |
26 | - 链表中节点的数目在范围
[0, 200] 内
27 | -100 <= Node.val <= 100-200 <= x <= 200
30 |
👍 486👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code31_NextPermutation.java:
--------------------------------------------------------------------------------
1 | //实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。
2 | //
3 | // 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
4 | //
5 | // 必须 原地 修改，只允许使用额外常数空间。
6 | //
7 | //
8 | //
9 | // 示例 1：
10 | //
11 | //
12 | //输入：nums = [1,2,3]
13 | //输出：[1,3,2]
14 | //
15 | //
16 | // 示例 2：
17 | //
18 | //
19 | //输入：nums = [3,2,1]
20 | //输出：[1,2,3]
21 | //
22 | //
23 | // 示例 3：
24 | //
25 | //
26 | //输入：nums = [1,1,5]
27 | //输出：[1,5,1]
28 | //
29 | //
30 | // 示例 4：
31 | //
32 | //
33 | //输入：nums = [1]
34 | //输出：[1]
35 | //
36 | //
37 | //
38 | //
39 | // 提示：
40 | //
41 | //
42 | // 1 <= nums.length <= 100
43 | // 0 <= nums[i] <= 100
44 | //
45 | // Related Topics 数组 双指针 👍 1418 👎 0
46 |
47 | package leetcode.editor.cn;
48 | public class Code31_NextPermutation {
49 | //leetcode submit region begin(Prohibit modification and deletion)
50 | class Solution {
51 | public void nextPermutation(int[] nums) {
52 |
53 | }
54 | }
55 | //leetcode submit region end(Prohibit modification and deletion)
56 |
57 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 04_ErWeiShuZuZhongDeChaZhaoLcof.md:
--------------------------------------------------------------------------------
1 | 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
2 |
3 |
4 |
5 | 示例:
6 |
7 | 现有矩阵 matrix 如下：
8 |
9 |
10 | [
11 | [1, 4, 7, 11, 15],
12 | [2, 5, 8, 12, 19],
13 | [3, 6, 9, 16, 22],
14 | [10, 13, 14, 17, 24],
15 | [18, 21, 23, 26, 30]
16 | ]
17 |
18 |
19 | 给定 target = 5，返回 true。
20 |
21 | 给定 target = 20，返回 false。
22 |
23 |
24 |
25 | 限制：
26 |
27 | 0 <= n <= 1000
28 |
29 | 0 <= m <= 1000
30 |
31 |
32 |
33 | 注意：本题与主站 240 题相同：https://leetcode-cn.com/problems/search-a-2d-matrix-ii/
34 |
👍 508👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer II 006_KLl5u1.java:
--------------------------------------------------------------------------------
1 | /**
2 | * English description is not available for the problem. Please switch to Chinese.
3 | *
👍 17👎 0
4 | */
5 | package leetcode.editor.cn;
6 |
7 | // 剑指 Offer II 006.排序数组中两个数字之和
8 | class Code_Offer_KLl5u1 {
9 |
10 | //leetcode submit region begin(Prohibit modification and deletion)
11 | class Solution {
12 |
13 | // 双指针
14 | public int[] twoSum(int[] numbers, int target) {
15 | int left = 0;
16 | int right = numbers.length - 1;
17 |
18 | while (left < right) {
19 | if (numbers[left] + numbers[right] == target) {
20 | return new int[]{left, right};
21 | } else if (numbers[left] + numbers[right] < target) {
22 | left++;
23 | } else {
24 | right--;
25 | }
26 | }
27 | return null;
28 |
29 | }
30 | }
31 | //leetcode submit region end(Prohibit modification and deletion)
32 |
33 | }
--------------------------------------------------------------------------------
/spark/pom.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 | bigdata
7 | groupId
8 | 1.0-SNAPSHOT
9 |
10 | 4.0.0
11 |
12 | spark
13 |
14 |
15 | 8
16 | 8
17 |
18 |
19 |
20 |
21 | org.apache.spark
22 | spark-core_2.12
23 | 3.1.2
24 |
25 |
26 | org.apache.spark
27 | spark-sql_2.12
28 | 3.1.2
29 |
30 |
31 |
32 |
33 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution60.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.HashMap;
4 | import java.util.Map.Entry;
5 | import java.util.PriorityQueue;
6 |
7 | // 出现频率最高的 k 个数字
8 | public class Solution60 {
9 |
10 | public int[] topKFrequent(int[] nums, int k) {
11 | HashMap map = new HashMap<>();
12 | for (int num : nums) {
13 | map.put(num, map.getOrDefault(num, 0) + 1);
14 | }
15 |
16 | PriorityQueue> minHeap = new PriorityQueue<>((e1, e2) -> e1.getValue() - e2.getValue());
17 |
18 | for (Entry entry : map.entrySet()) {
19 | if (minHeap.size() < k) {
20 | minHeap.offer(entry);
21 | } else if (entry.getValue() > minHeap.peek().getValue()) {
22 | minHeap.poll();
23 | minHeap.offer(entry);
24 | }
25 | }
26 |
27 | int[] ans = new int[k];
28 | int i = 0;
29 |
30 | for (Entry entry : minHeap) {
31 | ans[i++] = entry.getKey();
32 | }
33 | return ans;
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code21_MergeTwoSortedLists.md:
--------------------------------------------------------------------------------
1 | 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
2 |
3 |
4 |
5 | 示例 1：
6 | 
7 |
8 | 输入：l1 = [1,2,4], l2 = [1,3,4]
9 | 输出：[1,1,2,3,4,4]
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：l1 = [], l2 = []
16 | 输出：[]
17 |
18 |
19 | 示例 3：
20 |
21 |
22 | 输入：l1 = [], l2 = [0]
23 | 输出：[0]
24 |
25 |
26 |
27 |
28 | 提示：
29 |
30 |
31 | - 两个链表的节点数目范围是
[0, 50]
32 | -100 <= Node.val <= 100l1 和 l2 均按 非递减顺序 排列
35 |
👍 2178👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code56_MergeIntervals.md:
--------------------------------------------------------------------------------
1 | 以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
9 | 输出：[[1,6],[8,10],[15,18]]
10 | 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
11 |
12 |
13 | 示例 2：
14 |
15 |
16 | 输入：intervals = [[1,4],[4,5]]
17 | 输出：[[1,5]]
18 | 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
19 |
20 |
21 |
22 | 提示：
23 |
24 |
25 | 1 <= intervals.length <= 104intervals[i].length == 20 <= starti <= endi <= 104
29 |
👍 1192👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 03_ShuZuZhongZhongFuDeShuZiLcof.java:
--------------------------------------------------------------------------------
1 | //找出数组中重复的数字。
2 | //
3 | //
4 | //在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请
5 | //找出数组中任意一个重复的数字。
6 | //
7 | // 示例 1：
8 | //
9 | // 输入：
10 | //[2, 3, 1, 0, 2, 5, 3]
11 | //输出：2 或 3
12 | //
13 | //
14 | //
15 | //
16 | // 限制：
17 | //
18 | // 2 <= n <= 100000
19 | // Related Topics 数组 哈希表 排序 👍 619 👎 0
20 |
21 | package leetcode.editor.cn;
22 |
23 | import java.util.HashMap;
24 | import java.util.HashSet;
25 |
26 | // 剑指 Offer 03.数组中重复的数字
27 | class Code_Offer_ShuZuZhongZhongFuDeShuZiLcof {
28 | //leetcode submit region begin(Prohibit modification and deletion)
29 | class Solution {
30 | public int findRepeatNumber(int[] nums) {
31 | HashSet set = new HashSet<>();
32 | for (int num : nums) {
33 | if (set.contains(num))
34 | return num;
35 | set.add(num);
36 | }
37 | return -1;
38 | }
39 | }
40 | //leetcode submit region end(Prohibit modification and deletion)
41 |
42 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 37_XuLieHuaErChaShuLcof.md:
--------------------------------------------------------------------------------
1 | 请实现两个函数，分别用来序列化和反序列化二叉树。
2 |
3 | 你需要设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。
4 |
5 | 提示：输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。
6 |
7 |
8 |
9 | 示例：
10 | 
11 |
12 | 输入：root = [1,2,3,null,null,4,5]
13 | 输出：[1,2,3,null,null,4,5]
14 |
15 |
16 |
17 |
18 | 注意：本题与主站 297 题相同：https://leetcode-cn.com/problems/serialize-and-deserialize-binary-tree/
19 | Related Topics
树深度优先搜索广度优先搜索设计字符串二叉树
👍 249👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution79.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.LinkedList;
4 | import java.util.List;
5 |
6 | // 所有子集
7 | public class Solution79 {
8 |
9 | public List> subsets(int[] nums) {
10 | List> ans = new LinkedList<>();
11 | if (nums.length == 0) {
12 | return ans;
13 | }
14 | dfs(nums, ans, 0, new LinkedList());
15 | return ans;
16 | }
17 |
18 | /**
19 | * @param nums 数组
20 | * @param ans 答案
21 | * @param index 数组下标
22 | * @param subset 状态
23 | */
24 | private void dfs(int[] nums, List> ans, int index, LinkedList subset) {
25 | // base case
26 | if (index == nums.length) {
27 | ans.add(new LinkedList<>(subset));
28 | } else if (index < nums.length) {
29 | // 不选择当前的数字
30 | dfs(nums, ans, index + 1, subset);
31 |
32 | // 选择当前的数字
33 | subset.add(nums[index]);
34 | dfs(nums, ans, index + 1, subset);
35 | // 遍历完子树后回到当前位置
36 | subset.removeLast();
37 | }
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code64_MinimumPathSum.md:
--------------------------------------------------------------------------------
1 | 给定一个包含非负整数的 m x n 网格 grid ，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
2 |
3 | 说明：每次只能向下或者向右移动一步。
4 |
5 |
6 |
7 | 示例 1：
8 | 
9 |
10 | 输入：grid = [[1,3,1],[1,5,1],[4,2,1]]
11 | 输出：7
12 | 解释：因为路径 1→3→1→1→1 的总和最小。
13 |
14 |
15 | 示例 2：
16 |
17 |
18 | 输入：grid = [[1,2,3],[4,5,6]]
19 | 输出：12
20 |
21 |
22 |
23 |
24 | 提示：
25 |
26 |
27 | m == grid.lengthn == grid[i].length1 <= m, n <= 2000 <= grid[i][j] <= 100
32 |
👍 1069👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 27_ErChaShuDeJingXiangLcof.md:
--------------------------------------------------------------------------------
1 | 请完成一个函数，输入一个二叉树，该函数输出它的镜像。
2 |
3 | 例如输入：
4 |
5 | 4
6 | / \
7 | 2 7
8 | / \ / \
9 | 1 3 6 9
10 | 镜像输出：
11 |
12 | 4
13 | / \
14 | 7 2
15 | / \ / \
16 | 9 6 3 1
17 |
18 |
19 |
20 | 示例 1：
21 |
22 | 输入：root = [4,2,7,1,3,6,9]
23 | 输出：[4,7,2,9,6,3,1]
24 |
25 |
26 |
27 |
28 | 限制：
29 |
30 | 0 <= 节点个数 <= 1000
31 |
32 | 注意：本题与主站 226 题相同：https://leetcode-cn.com/problems/invert-binary-tree/
33 | Related Topics
树深度优先搜索广度优先搜索二叉树
👍 192👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution50.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import com.data.entity.TreeNode;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 |
7 | // 向下的路径节点之和：节点和为targetSum的路径个数
8 | public class Solution50 {
9 |
10 | public int pathSum(TreeNode root, int targetSum) {
11 | HashMap map = new HashMap<>();
12 | map.put(0, 1);
13 |
14 | return dfs(root, targetSum, 0, map);
15 | }
16 |
17 | // 节点和为targetSum的路径个数: 先序遍历 + 前缀和
18 | private int dfs(TreeNode root, int targetSum, int path, Map map) {
19 | // base case
20 | if (root == null) {
21 | return 0;
22 | }
23 |
24 | // 先序遍历
25 | path += root.val;
26 | int count = map.getOrDefault(path - targetSum, 0);
27 | map.put(path, map.getOrDefault(path, 0) + 1);
28 |
29 | // 左右子树
30 | count += dfs(root.left, targetSum, path, map);
31 | count += dfs(root.left, targetSum, path, map);
32 |
33 | // 遍历完左右子树后，再次来到了root，将path的数据减去
34 | map.put(path, map.get(path) - 1);
35 | return count;
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code24_SwapNodesInPairs.md:
--------------------------------------------------------------------------------
1 | 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
2 |
3 | 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
4 |
5 |
6 |
7 | 示例 1：
8 | 
9 |
10 | 输入：head = [1,2,3,4]
11 | 输出：[2,1,4,3]
12 |
13 |
14 | 示例 2：
15 |
16 |
17 | 输入：head = []
18 | 输出：[]
19 |
20 |
21 | 示例 3：
22 |
23 |
24 | 输入：head = [1]
25 | 输出：[1]
26 |
27 |
28 |
29 |
30 | 提示：
31 |
32 |
33 | - 链表中节点的数目在范围
[0, 100] 内
34 | 0 <= Node.val <= 100
36 |
37 |
38 |
39 | 进阶：你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）
40 |
👍 1114👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code82_RemoveDuplicatesFromSortedListIi.md:
--------------------------------------------------------------------------------
1 | 存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除链表中所有存在数字重复情况的节点，只保留原始链表中 没有重复出现 的数字。
2 |
3 | 返回同样按升序排列的结果链表。
4 |
5 |
6 |
7 | 示例 1：
8 | 
9 |
10 | 输入：head = [1,2,3,3,4,4,5]
11 | 输出：[1,2,5]
12 |
13 |
14 | 示例 2：
15 | 
16 |
17 | 输入：head = [1,1,1,2,3]
18 | 输出：[2,3]
19 |
20 |
21 |
22 |
23 | 提示：
24 |
25 |
26 | - 链表中节点数目在范围
[0, 300] 内
27 | -100 <= Node.val <= 100- 题目数据保证链表已经按升序排列
29 |
30 |
👍 751👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 55 - II_PingHengErChaShuLcof.md:
--------------------------------------------------------------------------------
1 | 输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。
2 |
3 |
4 |
5 | 示例 1:
6 |
7 | 给定二叉树 [3,9,20,null,null,15,7]
8 |
9 |
10 | 3
11 | / \
12 | 9 20
13 | / \
14 | 15 7
15 |
16 | 返回 true 。
17 |
18 | 示例 2:
19 |
20 | 给定二叉树 [1,2,2,3,3,null,null,4,4]
21 |
22 |
23 | 1
24 | / \
25 | 2 2
26 | / \
27 | 3 3
28 | / \
29 | 4 4
30 |
31 |
32 | 返回 false 。
33 |
34 |
35 |
36 | 限制：
37 |
38 |
39 | 0 <= 树的结点个数 <= 10000
41 |
42 | 注意：本题与主站 110 题相同：https://leetcode-cn.com/problems/balanced-binary-tree/
43 |
44 |
45 |
👍 204👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code56_MergeIntervals.java:
--------------------------------------------------------------------------------
1 | //以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返
2 | //回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
3 | //
4 | //
5 | //
6 | // 示例 1：
7 | //
8 | //
9 | //输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
10 | //输出：[[1,6],[8,10],[15,18]]
11 | //解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
12 | //
13 | //
14 | // 示例 2：
15 | //
16 | //
17 | //输入：intervals = [[1,4],[4,5]]
18 | //输出：[[1,5]]
19 | //解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
20 | //
21 | //
22 | //
23 | // 提示：
24 | //
25 | //
26 | // 1 <= intervals.length <= 10⁴
27 | // intervals[i].length == 2
28 | // 0 <= starti <= endi <= 10⁴
29 | //
30 | // Related Topics 数组 排序 👍 1192 👎 0
31 |
32 | package leetcode.editor.cn;
33 |
34 | // 56.合并区间
35 | public class Code56_MergeIntervals {
36 |
37 | //leetcode submit region begin(Prohibit modification and deletion)
38 | class Solution {
39 |
40 | // 剑指offer-2:排序
41 | public int[][] merge(int[][] intervals) {
42 | return null;
43 |
44 | }
45 | }
46 | //leetcode submit region end(Prohibit modification and deletion)
47 |
48 | }
--------------------------------------------------------------------------------
/spark/src/main/scala/com/data/spark/sql/CreateDF.scala:
--------------------------------------------------------------------------------
1 | package com.data.spark.sql
2 |
3 | import org.apache.spark.sql.SparkSession
4 |
5 | /**
6 | * 创建DataFrame
7 | */
8 | object CreateDF {
9 | def main(args: Array[String]): Unit = {
10 | val spark = SparkSession.builder()
11 | .master("local[1]")
12 | .appName(this.getClass.getSimpleName)
13 | .getOrCreate()
14 |
15 | import spark.implicits._
16 | // 1. 从RDD中创建
17 | val seq = Seq(("Bob", 14), ("Alice", 18))
18 | val df1 = spark.sparkContext.parallelize(seq).toDF("name", "age")
19 |
20 | // 2. 从文件系统创建 DataFrame
21 | spark.read.parquet("")
22 | spark.read.orc("")
23 |
24 | // 3. 数据库读取
25 | spark.read.format("jdbc")
26 | .option("driver", "com.mysql.jdbc.Driver")
27 | .option("url", "jdbc:mysql://hostname:port/mysql")
28 | .option("user", "用户名")
29 | .option("password", "密码")
30 | .option("numPartitions", 20)
31 | .option("dbtable", "数据表名 ")
32 | .load()
33 |
34 | // 3. hive表
35 |
36 | df1.show()
37 |
38 |
39 | spark.stop()
40 |
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution15.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.ArrayList;
4 | import java.util.List;
5 |
6 | // 字符串中的所有变位词
7 | public class Solution15 {
8 |
9 | public List findAnagrams(String s1, String s2) {
10 | List list = new ArrayList<>();
11 | if (s1.length() < s2.length()) {
12 | return list;
13 | }
14 |
15 | int[] counts = new int[26];
16 | for (int i = 0; i < s2.length(); i++) {
17 | counts[s2.charAt(i) - 'a']++;
18 | counts[s1.charAt(i) - 'a']--;
19 | }
20 | if (check(counts)) {
21 | list.add(0);
22 | }
23 |
24 | for (int i = s2.length(); i < s1.length(); i++) {
25 | counts[s2.charAt(i) - 'a']--;
26 | counts[s2.charAt(i - s1.length()) - 'a']++;
27 | if (check(counts)) {
28 | list.add(i - 1);
29 | }
30 | }
31 | return list;
32 | }
33 |
34 | private boolean check(int[] counts) {
35 | for (int count : counts) {
36 | if (count != 0) {
37 | return false;
38 | }
39 | }
40 | return true;
41 | }
42 |
43 | }
44 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution46.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import com.data.entity.TreeNode;
4 | import java.util.ArrayList;
5 | import java.util.LinkedList;
6 | import java.util.List;
7 | import java.util.Queue;
8 |
9 | // 二叉树的右侧视图
10 | public class Solution46 {
11 |
12 | // 每一层遍历完的时候的当前节点
13 | public List rightSideView(TreeNode root) {
14 | List ans = new ArrayList<>();
15 | if (root == null) {
16 | return ans;
17 | }
18 |
19 | Queue queue1 = new LinkedList<>();
20 | Queue queue2 = new LinkedList<>();
21 | queue1.offer(root);
22 |
23 | while (!queue1.isEmpty()) {
24 | TreeNode node = queue1.poll();
25 |
26 | if (node.left != null) {
27 | queue2.offer(node.left);
28 | }
29 | if (node.right != null) {
30 | queue2.offer(node.right);
31 | }
32 |
33 | // 当前层遍历完的时候
34 | if (queue1.isEmpty()) {
35 | ans.add(node.val);
36 | queue1 = queue2;
37 | queue2 = new LinkedList<>();
38 | }
39 | }
40 | return ans;
41 | }
42 | }
43 |
--------------------------------------------------------------------------------
/juc/src/main/java/com/big/data/thread/VolatileTest.java:
--------------------------------------------------------------------------------
1 | package com.big.data.thread;
2 |
3 | public class VolatileTest {
4 |
5 | // volatile保证可见性
6 | private static volatile boolean val = true;
7 |
8 | //private static volatile boolean val = true;
9 | public static void main(String[] args) {
10 | new VolatileTest().new First().start();
11 | new VolatileTest().new Second().start();
12 | }
13 |
14 | class First extends Thread {
15 |
16 | @Override
17 | public void run() {
18 | while (true) {
19 | if (val) {
20 | System.out.println("Thread one is working.");
21 | val = false;
22 | }
23 | }
24 | }
25 | }
26 |
27 | class Second extends Thread {
28 |
29 | @Override
30 | public void run() {
31 | while (true) {
32 | if (!val) {
33 | System.out.println("Thread two is working.");
34 | try {
35 | Thread.sleep(1000);
36 | } catch (InterruptedException e) {
37 | e.printStackTrace();
38 | }
39 | val = true;
40 | }
41 | }
42 | }
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code203_RemoveLinkedListElements.md:
--------------------------------------------------------------------------------
1 | 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
2 |
3 |
4 | 示例 1：
5 | 
6 |
7 | 输入：head = [1,2,6,3,4,5,6], val = 6
8 | 输出：[1,2,3,4,5]
9 |
10 |
11 | 示例 2：
12 |
13 |
14 | 输入：head = [], val = 1
15 | 输出：[]
16 |
17 |
18 | 示例 3：
19 |
20 |
21 | 输入：head = [7,7,7,7], val = 7
22 | 输出：[]
23 |
24 |
25 |
26 |
27 | 提示：
28 |
29 |
30 | - 列表中的节点数目在范围
[0, 104] 内
31 | 1 <= Node.val <= 500 <= val <= 50
34 |
👍 750👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code49_GroupAnagrams.md:
--------------------------------------------------------------------------------
1 | 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
2 |
3 | 字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。
4 |
5 |
6 |
7 | 示例 1:
8 |
9 |
10 | 输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
11 | 输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
12 |
13 | 示例 2:
14 |
15 |
16 | 输入: strs = [""]
17 | 输出: [[""]]
18 |
19 |
20 | 示例 3:
21 |
22 |
23 | 输入: strs = ["a"]
24 | 输出: [["a"]]
25 |
26 |
27 |
28 | 提示：
29 |
30 |
31 | 1 <= strs.length <= 1040 <= strs[i].length <= 100strs[i] 仅包含小写字母
35 |
👍 992👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution45.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import com.data.entity.TreeNode;
4 | import java.util.LinkedList;
5 | import java.util.Queue;
6 |
7 | // 二叉树最底层最左边的值
8 | public class Solution45 {
9 |
10 | public int findBottomLeftValue(TreeNode root) {
11 | // 当每一层遍历完的时候，当前出队的元素的下一个元素就是最左边的值
12 | Queue queue1 = new LinkedList<>();
13 | Queue queue2 = new LinkedList<>();
14 | queue1.offer(root);
15 | int leftValue = root.val;
16 |
17 | while (!queue1.isEmpty()) {
18 | TreeNode node = queue1.poll();
19 | if (node.left != null) {
20 | queue2.offer(node.left);
21 | }
22 | if (node.right != null) {
23 | queue2.offer(node.right);
24 | }
25 |
26 | if (queue1.isEmpty()) { // 当前层遍历完了
27 | // queue2的第一个元素，就是下一层最左边的
28 | if (!queue2.isEmpty()) {
29 | TreeNode node1 = queue2.peek();
30 | leftValue = node1.val;
31 | }
32 |
33 | queue1 = queue2;
34 | queue2 = new LinkedList<>();
35 | }
36 | }
37 | return leftValue;
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 16_ShuZhiDeZhengShuCiFangLcof.java:
--------------------------------------------------------------------------------
1 | //实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xⁿ）。不得使用库函数，同时不需要考虑大数问题。
2 | //
3 | //
4 | //
5 | // 示例 1：
6 | //
7 | //
8 | //输入：x = 2.00000, n = 10
9 | //输出：1024.00000
10 | //
11 | //
12 | // 示例 2：
13 | //
14 | //
15 | //输入：x = 2.10000, n = 3
16 | //输出：9.26100
17 | //
18 | // 示例 3：
19 | //
20 | //
21 | //输入：x = 2.00000, n = -2
22 | //输出：0.25000
23 | //解释：2⁻² = 1/2² = 1/4 = 0.25
24 | //
25 | //
26 | //
27 | // 提示：
28 | //
29 | //
30 | // -100.0 < x < 100.0
31 | // -2³¹ <= n <= 2³¹-1
32 | // -10⁴ <= xⁿ <= 10⁴
33 | //
34 | //
35 | //
36 | //
37 | // 注意：本题与主站 50 题相同：https://leetcode-cn.com/problems/powx-n/
38 | // Related Topics 递归 数学 👍 222 👎 0
39 |
40 | package leetcode.editor.cn;
41 |
42 | // 剑指 Offer 16.数值的整数次方
43 | class Code_Offer_ShuZhiDeZhengShuCiFangLcof {
44 |
45 | //leetcode submit region begin(Prohibit modification and deletion)
46 | class Solution {
47 |
48 | public double myPow(double x, int n) {
49 | return Math.pow(x, n);
50 |
51 | }
52 | }
53 | //leetcode submit region end(Prohibit modification and deletion)
54 |
55 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 07_ZhongJianErChaShuLcof.md:
--------------------------------------------------------------------------------
1 | 输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。
2 |
3 | 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
4 |
5 |
6 |
7 | 示例 1:
8 | 
9 |
10 | Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
11 | Output: [3,9,20,null,null,15,7]
12 |
13 |
14 | 示例 2:
15 |
16 |
17 | Input: preorder = [-1], inorder = [-1]
18 | Output: [-1]
19 |
20 |
21 |
22 |
23 | 限制：
24 |
25 | 0 <= 节点个数 <= 5000
26 |
27 |
28 |
29 | 注意：本题与主站 105 题重复：https://leetcode-cn.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
30 | Related Topics
树数组哈希表分治二叉树
👍 622👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 09_YongLiangGeZhanShiXianDuiLieLcof.md:
--------------------------------------------------------------------------------
1 | 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
2 |
3 |
4 |
5 | 示例 1：
6 |
7 | 输入：
8 | ["CQueue","appendTail","deleteHead","deleteHead"]
9 | [[],[3],[],[]]
10 | 输出：[null,null,3,-1]
11 |
12 |
13 | 示例 2：
14 |
15 | 输入：
16 | ["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
17 | [[],[],[5],[2],[],[]]
18 | 输出：[null,-1,null,null,5,2]
19 |
20 |
21 | 提示：
22 |
23 |
24 | 1 <= values <= 10000最多会对 appendTail、deleteHead 进行 10000 次调用
27 |
👍 365👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 59 - I_HuaDongChuangKouDeZuiDaZhiLcof.md:
--------------------------------------------------------------------------------
1 | 给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。
2 |
3 | 示例:
4 |
5 | 输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
6 | 输出: [3,3,5,5,6,7]
7 | 解释:
8 |
9 | 滑动窗口的位置 最大值
10 | --------------- -----
11 | [1 3 -1] -3 5 3 6 7 3
12 | 1 [3 -1 -3] 5 3 6 7 3
13 | 1 3 [-1 -3 5] 3 6 7 5
14 | 1 3 -1 [-3 5 3] 6 7 5
15 | 1 3 -1 -3 [5 3 6] 7 6
16 | 1 3 -1 -3 5 [3 6 7] 7
17 |
18 |
19 |
20 | 提示：
21 |
22 | 你可以假设 k 总是有效的，在输入数组不为空的情况下，1 ≤ k ≤ 输入数组的大小。
23 |
24 | 注意：本题与主站 239 题相同：https://leetcode-cn.com/problems/sliding-window-maximum/
25 | Related Topics
队列滑动窗口单调队列堆（优先队列）
👍 349👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer II 079_TVdhkn.md:
--------------------------------------------------------------------------------
1 | 给定一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
2 |
3 | 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：nums = [1,2,3]
11 | 输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
12 |
13 |
14 | 示例 2：
15 |
16 |
17 | 输入：nums = [0]
18 | 输出：[[],[0]]
19 |
20 |
21 |
22 |
23 | 提示：
24 |
25 |
26 | 1 <= nums.length <= 10-10 <= nums[i] <= 10nums 中的所有元素 互不相同
30 |
31 |
32 |
33 | 注意：本题与主站 78 题相同： https://leetcode-cn.com/problems/subsets/
34 |
👍 14👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code92_ReverseLinkedListIi.md:
--------------------------------------------------------------------------------
1 | 给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
2 |
3 |
4 | 示例 1：
5 | 
6 |
7 | 输入：head = [1,2,3,4,5], left = 2, right = 4
8 | 输出：[1,4,3,2,5]
9 |
10 |
11 | 示例 2：
12 |
13 |
14 | 输入：head = [5], left = 1, right = 1
15 | 输出：[5]
16 |
17 |
18 |
19 |
20 | 提示：
21 |
22 |
23 | - 链表中节点数目为
n
24 | 1 <= n <= 500-500 <= Node.val <= 5001 <= left <= right <= n
28 |
29 |
30 |
31 | 进阶： 你可以使用一趟扫描完成反转吗？
32 |
👍 1088👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 53 - II_QueShiDeShuZiLcof.java:
--------------------------------------------------------------------------------
1 | //一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出
2 | //这个数字。
3 | //
4 | //
5 | //
6 | // 示例 1:
7 | //
8 | // 输入: [0,1,3]
9 | //输出: 2
10 | //
11 | //
12 | // 示例 2:
13 | //
14 | // 输入: [0,1,2,3,4,5,6,7,9]
15 | //输出: 8
16 | //
17 | //
18 | //
19 | // 限制：
20 | //
21 | // 1 <= 数组长度 <= 10000
22 | // Related Topics 位运算 数组 哈希表 数学 二分查找 👍 188 👎 0
23 |
24 | package leetcode.editor.cn;
25 |
26 | // 剑指 Offer 53 - II.0～n-1中缺失的数字
27 | class Code_Offer_QueShiDeShuZiLcof {
28 |
29 | //leetcode submit region begin(Prohibit modification and deletion)
30 | class Solution {
31 |
32 | public int missingNumber(int[] nums) {
33 | int left = 0;
34 | int right = nums.length - 1;
35 |
36 | while (left <= right) {
37 | int mid = (left + right) / 2;
38 |
39 | if (nums[mid] == mid) {
40 | left = mid + 1;
41 | } else {
42 | right = mid - 1;
43 | }
44 | }
45 | return left;
46 | }
47 | }
48 | //leetcode submit region end(Prohibit modification and deletion)
49 |
50 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer II 008_TwoVG8Kg.java:
--------------------------------------------------------------------------------
1 | /**
2 | * English description is not available for the problem. Please switch to Chinese.
3 | * Related Topics
数组二分查找前缀和滑动窗口
👍 34👎 0
4 | */
5 | package leetcode.editor.cn;
6 |
7 | // 剑指 Offer II 008.和大于等于 target 的最短子数组
8 | class Code_Offer_TwoVG8Kg {
9 |
10 | //leetcode submit region begin(Prohibit modification and deletion)
11 | class Solution {
12 |
13 | // 双指针，left与right之间维持大于等于 target的一个子序和
14 | public int minSubArrayLen(int target, int[] nums) {
15 |
16 | int left = 0;
17 | int sum = 0;
18 | int size = Integer.MAX_VALUE;
19 | for (int right = 0; right < nums.length; right++) {
20 | sum += nums[right];
21 | while (sum >= target) {
22 | size = Math.min(size, right - left + 1);
23 | sum -= nums[left];
24 | left++;
25 | }
26 | }
27 | return size == Integer.MAX_VALUE ? 0 : size;
28 | }
29 | }
30 | //leetcode submit region end(Prohibit modification and deletion)
31 |
32 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code704_BinarySearch.md:
--------------------------------------------------------------------------------
1 | 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
2 |
3 |
4 | 示例 1:
5 |
6 | 输入: nums = [-1,0,3,5,9,12], target = 9
7 | 输出: 4
8 | 解释: 9 出现在 nums 中并且下标为 4
9 |
10 |
11 | 示例 2:
12 |
13 | 输入: nums = [-1,0,3,5,9,12], target = 2
14 | 输出: -1
15 | 解释: 2 不存在 nums 中因此返回 -1
16 |
17 |
18 |
19 |
20 | 提示：
21 |
22 |
23 | - 你可以假设
nums 中的所有元素是不重复的。
24 | n 将在 [1, 10000]之间。nums 的每个元素都将在 [-9999, 9999]之间。
27 |
👍 621👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 14- II_JianShengZiIiLcof.md:
--------------------------------------------------------------------------------
1 | 给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m - 1] 。请问 k[0]*k[1]*...*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
2 |
3 | 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 | 输入: 2
10 | 输出: 1
11 | 解释: 2 = 1 + 1, 1 × 1 = 1
12 |
13 | 示例 2:
14 |
15 | 输入: 10
16 | 输出: 36
17 | 解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36
18 |
19 |
20 |
21 | 提示：
22 |
23 |
26 |
27 | 注意：本题与主站 343 题相同：https://leetcode-cn.com/problems/integer-break/
28 |
👍 144👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution36.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.Stack;
4 |
5 | // 后缀表达式 +、-、*、/
6 | public class Solution36 {
7 | public int evalRPN(String[] tokens) {
8 | Stack stack = new Stack<>();
9 | for (String c : tokens) {
10 | switch (c) {
11 | case "+":
12 | case "-":
13 | case "*":
14 | case "/":
15 | int num2 = stack.pop();
16 | int num1 = stack.pop();
17 | stack.push(calc(num1, num2, c));
18 | break;
19 | default:
20 | stack.push(Integer.parseInt(c));
21 | }
22 | }
23 | return stack.pop();
24 | }
25 |
26 | private int calc(int a, int b, String op) {
27 | switch (op) {
28 | case "+":
29 | return a + b;
30 | case "-":
31 | return a - b;
32 | case "*":
33 | return a * b;
34 | default:
35 | return a / b;
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code50_PowxN.md:
--------------------------------------------------------------------------------
1 | 实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。
2 |
3 |
4 |
5 | 示例 1：
6 |
7 |
8 | 输入：x = 2.00000, n = 10
9 | 输出：1024.00000
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：x = 2.10000, n = 3
16 | 输出：9.26100
17 |
18 |
19 | 示例 3：
20 |
21 |
22 | 输入：x = 2.00000, n = -2
23 | 输出：0.25000
24 | 解释：2-2 = 1/22 = 1/4 = 0.25
25 |
26 |
27 |
28 |
29 | 提示：
30 |
31 |
32 | -100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104
36 |
👍 795👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution39.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.Stack;
4 |
5 | // 直方图的最大矩形面积
6 | public class Solution39 {
7 | public int largestRectangleArea(int[] nums) {
8 | if (nums == null || nums.length == 0)
9 | return 0;
10 |
11 | int maxArea = 0;
12 | Stack stack = new Stack<>();
13 |
14 | for (int i = 0; i < nums.length; i++) {
15 | while (!stack.empty() && nums[i] < nums[stack.peek()]) { // 维持递增栈，当前位置小于栈顶，出栈
16 | int j = stack.pop();
17 | int left = stack.empty() ? -1 : stack.peek();
18 | int area = (i - left - 1) * nums[j];
19 | maxArea = Math.max(maxArea, area);
20 | }
21 | stack.push(i);
22 | }
23 |
24 | // 将栈中剩下的递增的元素弹出，并计算面积
25 | while (!stack.empty()) {
26 | int j = stack.pop();
27 | int left = stack.empty() ? -1 : stack.peek();
28 | int area = (nums.length - left - 1) * nums[j];
29 | maxArea = Math.max(maxArea, area);
30 | }
31 | return maxArea;
32 | }
33 | }
34 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code121_BestTimeToBuyAndSellStock.md:
--------------------------------------------------------------------------------
1 | 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
2 |
3 | 你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
4 |
5 | 返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：[7,1,5,3,6,4]
13 | 输出：5
14 | 解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
15 | 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
16 |
17 |
18 | 示例 2：
19 |
20 |
21 | 输入：prices = [7,6,4,3,1]
22 | 输出：0
23 | 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
24 |
25 |
26 |
27 |
28 | 提示：
29 |
30 |
31 | 1 <= prices.length <= 1050 <= prices[i] <= 104
34 |
👍 2085👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code234_PalindromeLinkedList.md:
--------------------------------------------------------------------------------
1 | 给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
2 |
3 |
4 |
5 | 示例 1：
6 | 
7 |
8 | 输入：head = [1,2,2,1]
9 | 输出：true
10 |
11 |
12 | 示例 2：
13 | 
14 |
15 | 输入：head = [1,2]
16 | 输出：false
17 |
18 |
19 |
20 |
21 | 提示：
22 |
23 |
24 | - 链表中节点数目在范围
[1, 105] 内
25 | 0 <= Node.val <= 9
27 |
28 |
29 |
30 | 进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
31 |
👍 1184👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 53 - I_ZaiPaiXuShuZuZhongChaZhaoShuZiLcof.md:
--------------------------------------------------------------------------------
1 | 统计一个数字在排序数组中出现的次数。
2 |
3 |
4 |
5 | 示例 1:
6 |
7 |
8 | 输入: nums = [5,7,7,8,8,10], target = 8
9 | 输出: 2
10 |
11 | 示例 2:
12 |
13 |
14 | 输入: nums = [5,7,7,8,8,10], target = 6
15 | 输出: 0
16 |
17 |
18 |
19 | 提示：
20 |
21 |
22 | 0 <= nums.length <= 105-109 <= nums[i] <= 109nums 是一个非递减数组-109 <= target <= 109
27 |
28 |
29 |
30 | 注意：本题与主站 34 题相同（仅返回值不同）：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/
31 |
👍 225👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution89.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 |
4 | // 房屋偷盗
5 | public class Solution89 {
6 |
7 | // 不能挨着偷
8 | public int rob(int[] nums) {
9 | if (nums == null || nums.length == 0) {
10 | return 0;
11 | }
12 |
13 | int n = nums.length;
14 | // dp[i]表示偷到i位置时所能偷到的最多的钱
15 | int[] dp = new int[n];
16 | dp[0] = nums[0];
17 | if (n > 1) {
18 | dp[1] = Math.max(nums[0], nums[1]); // 偷0位置或者1位置
19 | }
20 |
21 | for (int i = 2; i < n; i++) {
22 | dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]); // 偷当前位置或者不偷
23 | }
24 | return dp[n - 1];
25 | }
26 |
27 | public int rob2(int[] nums) {
28 | if (nums == null || nums.length == 0) {
29 | return 0;
30 | }
31 | int n = nums.length;
32 | if (n == 1) {
33 | return nums[0];
34 | }
35 |
36 | int first = nums[0];
37 | int second = Math.max(nums[0], nums[1]);
38 |
39 | for (int i = 2; i < nums.length; i++) {
40 | // 偷当前位置或者不偷
41 | int tmp = second;
42 | second = Math.max(second, first + nums[i]);
43 | first = tmp;
44 | }
45 | return second;
46 | }
47 |
48 | }
49 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code53_MaximumSubarray.md:
--------------------------------------------------------------------------------
1 | 给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
2 |
3 | 子数组 是数组中的一个连续部分。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
11 | 输出：6
12 | 解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
13 |
14 |
15 | 示例 2：
16 |
17 |
18 | 输入：nums = [1]
19 | 输出：1
20 |
21 |
22 | 示例 3：
23 |
24 |
25 | 输入：nums = [5,4,-1,7,8]
26 | 输出：23
27 |
28 |
29 |
30 |
31 | 提示：
32 |
33 |
34 | 1 <= nums.length <= 105-104 <= nums[i] <= 104
37 |
38 |
39 |
40 | 进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。
41 |
👍 4285👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code19_RemoveNthNodeFromEndOfList.md:
--------------------------------------------------------------------------------
1 | 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
2 |
3 |
4 |
5 | 示例 1：
6 | 
7 |
8 | 输入：head = [1,2,3,4,5], n = 2
9 | 输出：[1,2,3,5]
10 |
11 |
12 | 示例 2：
13 |
14 |
15 | 输入：head = [1], n = 1
16 | 输出：[]
17 |
18 |
19 | 示例 3：
20 |
21 |
22 | 输入：head = [1,2], n = 1
23 | 输出：[1]
24 |
25 |
26 |
27 |
28 | 提示：
29 |
30 |
31 | - 链表中结点的数目为
sz
32 | 1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz
36 |
37 |
38 |
39 | 进阶：你能尝试使用一趟扫描实现吗？
40 |
👍 1662👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code739_DailyTemperatures.md:
--------------------------------------------------------------------------------
1 | 请根据每日 气温 列表 temperatures ，请计算在每一天需要等几天才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 0 来代替。
2 |
3 | 示例 1:
4 |
5 |
6 | 输入: temperatures = [73,74,75,71,69,72,76,73]
7 | 输出: [1,1,4,2,1,1,0,0]
8 |
9 |
10 | 示例 2:
11 |
12 |
13 | 输入: temperatures = [30,40,50,60]
14 | 输出: [1,1,1,0]
15 |
16 |
17 | 示例 3:
18 |
19 |
20 | 输入: temperatures = [30,60,90]
21 | 输出: [1,1,0]
22 |
23 |
24 |
25 | 提示：
26 |
27 |
28 | 1 <= temperatures.length <= 10530 <= temperatures[i] <= 100
31 |
👍 1011👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution81.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.LinkedList;
4 | import java.util.List;
5 |
6 | // 允许重复选择元素的组合
7 | // 给定一个没有重复数字的正整数集合，请找出所有元素之和等于某个给定值的所有组合。同一个数字可以在组合中出现任意次。
8 | // 例如，输入整数集合[2，3，5]，元素之和等于8的组合有3个，分别是[2，2，2，2]、[2，3，3]和[3，5]。
9 | public class Solution81 {
10 |
11 | public List> combinationSum(int[] candidates, int target) {
12 | List> ans = new LinkedList<>();
13 | LinkedList subset = new LinkedList<>();
14 |
15 | // 在数组下标从0开始选择
16 | dfs(candidates, target, 0, ans, subset);
17 | return ans;
18 | }
19 |
20 | private void dfs(int[] candidates, int target, int index, List> ans,
21 | LinkedList subset) {
22 | // base case
23 | if (target == 0) {
24 | ans.add(new LinkedList<>(subset));
25 | } else if (target > 0 && index < candidates.length) {
26 | // 不要当前的元素
27 | dfs(candidates, target, index +1, ans, subset);
28 | // 要当前的元素
29 | subset.add(candidates[index]);
30 | dfs(candidates, target - candidates[index], index, ans, subset);
31 | subset.removeLast();
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code17_LetterCombinationsOfAPhoneNumber.md:
--------------------------------------------------------------------------------
1 | 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
2 |
3 | 给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
4 |
5 | 
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：digits = "23"
13 | 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"]
14 |
15 |
16 | 示例 2：
17 |
18 |
19 | 输入：digits = ""
20 | 输出：[]
21 |
22 |
23 | 示例 3：
24 |
25 |
26 | 输入：digits = "2"
27 | 输出：["a","b","c"]
28 |
29 |
30 |
31 |
32 | 提示：
33 |
34 |
35 | 0 <= digits.length <= 4digits[i] 是范围 ['2', '9'] 的一个数字。
38 |
👍 1615👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer II 019_RQku0D.md:
--------------------------------------------------------------------------------
1 | 给定一个非空字符串 s，请判断如果 最多 从字符串中删除一个字符能否得到一个回文字符串。
2 |
3 |
4 |
5 | 示例 1:
6 |
7 |
8 | 输入: s = "aba"
9 | 输出: true
10 |
11 |
12 | 示例 2:
13 |
14 |
15 | 输入: s = "abca"
16 | 输出: true
17 | 解释: 可以删除 "c" 字符 或者 "b" 字符
18 |
19 |
20 | 示例 3:
21 |
22 |
23 | 输入: s = "abc"
24 | 输出: false
25 |
26 |
27 |
28 | 提示:
29 |
30 |
31 | 1 <= s.length <= 105s 由小写英文字母组成
34 |
35 |
36 |
37 | 注意：本题与主站 680 题相同： https://leetcode-cn.com/problems/valid-palindrome-ii/
38 |
👍 21👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code69_Sqrtx.java:
--------------------------------------------------------------------------------
1 | //给你一个非负整数 x ，计算并返回 x 的 算术平方根 。
2 | //
3 | // 由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。
4 | //
5 | // 注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。
6 | //
7 | //
8 | //
9 | // 示例 1：
10 | //
11 | //
12 | //输入：x = 4
13 | //输出：2
14 | //
15 | //
16 | // 示例 2：
17 | //
18 | //
19 | //输入：x = 8
20 | //输出：2
21 | //解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。
22 | //
23 | //
24 | //
25 | //
26 | // 提示：
27 | //
28 | //
29 | // 0 <= x <= 2³¹ - 1
30 | //
31 | // Related Topics 数学 二分查找 👍 879 👎 0
32 |
33 | package leetcode.editor.cn;
34 |
35 | // 69.x 的平方根
36 | public class Code69_Sqrtx {
37 |
38 | //leetcode submit region begin(Prohibit modification and deletion)
39 | class Solution {
40 |
41 | public int mySqrt(int x) {
42 |
43 | int left = 1;
44 | int right = x;
45 |
46 | while (left < right) {
47 | int mid = (left + right + 1) / 2;
48 | if (mid * mid <= x) {
49 | // 答案是mid或者mid的右边
50 | left = mid;
51 | } else {
52 | right = mid - 1;
53 | }
54 | }
55 | return right;
56 | }
57 | }
58 | //leetcode submit region end(Prohibit modification and deletion)
59 |
60 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 21_DiaoZhengShuZuShunXuShiQiShuWeiYuOuShuQianMianLcof.java:
--------------------------------------------------------------------------------
1 | //输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数在数组的前半部分，所有偶数在数组的后半部分。
2 | //
3 | //
4 | //
5 | // 示例：
6 | //
7 | //
8 | //输入：nums = [1,2,3,4]
9 | //输出：[1,3,2,4]
10 | //注：[3,1,2,4] 也是正确的答案之一。
11 | //
12 | //
13 | //
14 | // 提示：
15 | //
16 | //
17 | // 0 <= nums.length <= 50000
18 | // 0 <= nums[i] <= 10000
19 | //
20 | // Related Topics 数组 双指针 排序 👍 175 👎 0
21 |
22 | package leetcode.editor.cn;
23 | // 剑指 Offer 21.调整数组顺序使奇数位于偶数前面
24 | class Code_Offer_DiaoZhengShuZuShunXuShiQiShuWeiYuOuShuQianMianLcof {
25 | //leetcode submit region begin(Prohibit modification and deletion)
26 | class Solution {
27 | public int[] exchange(int[] nums) {
28 | // i从左到右寻找偶数，j从右到左寻找奇数，然后交换
29 | int i = 0, j = nums.length - 1, tmp;
30 | while(i < j) {
31 | while(i < j && (nums[i] & 1) == 1) i++;
32 | while(i < j && (nums[j] & 1) == 0) j--;
33 | tmp = nums[i];
34 | nums[i] = nums[j];
35 | nums[j] = tmp;
36 | }
37 | return nums;
38 |
39 | }
40 | }
41 | //leetcode submit region end(Prohibit modification and deletion)
42 |
43 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 50_DiYiGeZhiChuXianYiCiDeZiFuLcof.java:
--------------------------------------------------------------------------------
1 | //在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。
2 | //
3 | // 示例 1:
4 | //
5 | //
6 | //输入：s = "abaccdeff"
7 | //输出：'b'
8 | //
9 | //
10 | // 示例 2:
11 | //
12 | //
13 | //输入：s = ""
14 | //输出：' '
15 | //
16 | //
17 | //
18 | //
19 | // 限制：
20 | //
21 | // 0 <= s 的长度 <= 50000
22 | // Related Topics 队列 哈希表 字符串 计数 👍 157 👎 0
23 |
24 | package leetcode.editor.cn;
25 |
26 | // 剑指 Offer 50.第一个只出现一次的字符
27 | class Code_Offer_DiYiGeZhiChuXianYiCiDeZiFuLcof {
28 |
29 | //leetcode submit region begin(Prohibit modification and deletion)
30 | class Solution {
31 |
32 | public char firstUniqChar(String s) {
33 | if (s == null || s.length() == 0) {
34 | return ' ';
35 | }
36 |
37 | int[] counts = new int[26];
38 | for (int i = 0; i < s.length(); i++) {
39 | counts[s.charAt(i) - 'a']++;
40 | }
41 |
42 | for (int i = 0; i < s.length(); i++) {
43 | if (counts[s.charAt(i) - 'a'] == 1) {
44 | return s.charAt(i);
45 | }
46 | }
47 | return ' ';
48 | }
49 | }
50 | //leetcode submit region end(Prohibit modification and deletion)
51 |
52 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer II 018_XltzEq.md:
--------------------------------------------------------------------------------
1 | 给定一个字符串 s ，验证 s 是否是 回文串 ，只考虑字母和数字字符，可以忽略字母的大小写。
2 |
3 | 本题中，将空字符串定义为有效的 回文串 。
4 |
5 |
6 |
7 | 示例 1:
8 |
9 |
10 | 输入: s = "A man, a plan, a canal: Panama"
11 | 输出: true
12 | 解释："amanaplanacanalpanama" 是回文串
13 |
14 | 示例 2:
15 |
16 |
17 | 输入: s = "race a car"
18 | 输出: false
19 | 解释："raceacar" 不是回文串
20 |
21 |
22 |
23 | 提示：
24 |
25 |
26 | 1 <= s.length <= 2 * 105- 字符串
s 由 ASCII 字符组成
28 |
29 |
30 |
31 |
32 | 注意：本题与主站 125 题相同： https://leetcode-cn.com/problems/valid-palindrome/
33 |
👍 15👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code148_SortList.md:
--------------------------------------------------------------------------------
1 | 给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
2 |
3 | 进阶：
4 |
5 |
6 | - 你可以在
O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
7 |
8 |
9 |
10 |
11 | 示例 1：
12 | 
13 |
14 | 输入：head = [4,2,1,3]
15 | 输出：[1,2,3,4]
16 |
17 |
18 | 示例 2：
19 | 
20 |
21 | 输入：head = [-1,5,3,4,0]
22 | 输出：[-1,0,3,4,5]
23 |
24 |
25 | 示例 3：
26 |
27 |
28 | 输入：head = []
29 | 输出：[]
30 |
31 |
32 |
33 |
34 | 提示：
35 |
36 |
37 | - 链表中节点的数目在范围
[0, 5 * 104] 内
38 | -105 <= Node.val <= 105
40 | Related Topics
链表双指针分治排序归并排序
👍 1385👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code162_FindPeakElement.md:
--------------------------------------------------------------------------------
1 | 峰值元素是指其值严格大于左右相邻值的元素。
2 |
3 | 给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
4 |
5 | 你可以假设 nums[-1] = nums[n] = -∞ 。
6 |
7 | 你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
8 |
9 |
10 |
11 | 示例 1：
12 |
13 |
14 | 输入：nums = [1,2,3,1]
15 | 输出：2
16 | 解释：3 是峰值元素，你的函数应该返回其索引 2。
17 |
18 | 示例 2：
19 |
20 |
21 | 输入：nums = [1,2,1,3,5,6,4]
22 | 输出：1 或 5
23 | 解释：你的函数可以返回索引 1，其峰值元素为 2；
24 | 或者返回索引 5， 其峰值元素为 6。
25 |
26 |
27 |
28 |
29 | 提示：
30 |
31 |
32 | 1 <= nums.length <= 1000-231 <= nums[i] <= 231 - 1- 对于所有有效的
i 都有 nums[i] != nums[i + 1]
35 |
36 |
👍 703👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code206_ReverseLinkedList.md:
--------------------------------------------------------------------------------
1 | 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
2 |
3 |
4 |
5 |
6 |
示例 1：
7 |
8 |
9 | 输入：head = [1,2,3,4,5]
10 | 输出：[5,4,3,2,1]
11 |
12 |
13 |
示例 2：
14 |
15 |
16 | 输入：head = [1,2]
17 | 输出：[2,1]
18 |
19 |
20 |
示例 3：
21 |
22 |
23 | 输入：head = []
24 | 输出：[]
25 |
26 |
27 |
28 |
29 |
提示：
30 |
31 |
32 | - 链表中节点的数目范围是
[0, 5000]
33 | -5000 <= Node.val <= 5000
35 |
36 |
37 |
38 |
进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
39 |
40 |
👍 2261👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code213_HouseRobberIi.md:
--------------------------------------------------------------------------------
1 | 你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
2 |
3 | 给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：nums = [2,3,2]
11 | 输出：3
12 | 解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。
13 |
14 |
15 | 示例 2：
16 |
17 |
18 | 输入：nums = [1,2,3,1]
19 | 输出：4
20 | 解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
21 | 偷窃到的最高金额 = 1 + 3 = 4 。
22 |
23 | 示例 3：
24 |
25 |
26 | 输入：nums = [1,2,3]
27 | 输出：3
28 |
29 |
30 |
31 |
32 | 提示：
33 |
34 |
35 | 1 <= nums.length <= 1000 <= nums[i] <= 1000
38 |
👍 909👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code437_PathSumIii.md:
--------------------------------------------------------------------------------
1 | 给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
2 |
3 | 路径 不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 | 
10 |
11 |
12 | 输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
13 | 输出：3
14 | 解释：和等于 8 的路径有 3 条，如图所示。
15 |
16 |
17 | 示例 2：
18 |
19 |
20 | 输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
21 | 输出：3
22 |
23 |
24 |
25 |
26 | 提示:
27 |
28 |
29 | - 二叉树的节点个数的范围是
[0,1000]
30 | -109 <= Node.val <= 109 -1000 <= targetSum <= 1000
33 |
👍 1151👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution11.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import java.util.HashMap;
4 |
5 | // 剑指 Offer II 011. 0 和 1 个数相同的子数组
6 | public class Solution11 {
7 |
8 | // 求最长连续子数组的长度
9 | // 前缀和：遇到1加1，遇到0就-1，若当前i前缀和为m，若之前存在一个位置j前缀和也是m，则长度为i - j，
10 | // 哈希表中应该存数组前缀和以及索引位置
11 | public int findMaxLength(int[] nums) {
12 | HashMap map = new HashMap<>();
13 | map.put(0, -1);
14 |
15 | int sum = 0;
16 | int size = 0;
17 |
18 | for (int i = 0; i < nums.length; i++) {
19 | sum += nums[i] == 1 ? 1 : -1;
20 | size = Math.max(size, i - map.getOrDefault(sum, i));
21 | map.put(sum, Math.min(map.getOrDefault(sum, i), i));
22 | }
23 | return size;
24 | }
25 |
26 | public int findMaxLength2(int[] nums) {
27 | HashMap map = new HashMap<>();
28 | map.put(0, -1);
29 |
30 | int sum = 0;
31 | int size = 0;
32 |
33 | for (int i = 0; i < nums.length; i++) {
34 | sum += nums[i] == 1 ? 1 : -1;
35 | if (map.containsKey(sum)) {
36 | size = Math.max(size, i - map.get(sum));
37 | } else {
38 | map.put(sum, i);
39 | }
40 | }
41 | return size;
42 | }
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code1248_CountNumberOfNiceSubarrays.md:
--------------------------------------------------------------------------------
1 | 给你一个整数数组 nums 和一个整数 k。如果某个连续子数组中恰好有 k 个奇数数字，我们就认为这个子数组是「优美子数组」。
2 |
3 | 请返回这个数组中 「优美子数组」 的数目。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入：nums = [1,1,2,1,1], k = 3
11 | 输出：2
12 | 解释：包含 3 个奇数的子数组是 [1,1,2,1] 和 [1,2,1,1] 。
13 |
14 |
15 | 示例 2：
16 |
17 |
18 | 输入：nums = [2,4,6], k = 1
19 | 输出：0
20 | 解释：数列中不包含任何奇数，所以不存在优美子数组。
21 |
22 |
23 | 示例 3：
24 |
25 |
26 | 输入：nums = [2,2,2,1,2,2,1,2,2,2], k = 2
27 | 输出：16
28 |
29 |
30 |
31 |
32 | 提示：
33 |
34 |
35 | 1 <= nums.length <= 500001 <= nums[i] <= 10^51 <= k <= nums.length
39 | Related Topics
数组哈希表数学滑动窗口
👍 203👎 0
--------------------------------------------------------------------------------
/spark/src/main/resources/data/wikiOfSpark.txt:
--------------------------------------------------------------------------------
1 | Apache Spark
2 | From Wikipedia, the free encyclopedia
3 | Jump to navigationJump to search
4 | Apache Spark
5 | Spark Logo
6 | Original author(s) Matei Zaharia
7 | Developer(s) Apache Spark
8 | Initial release May 26, 2014; 6 years ago
9 | Stable release
10 | 3.1.1 / March 2, 2021; 2 months ago
11 | Repository Spark Repository
12 | Written in Scala[1]
13 | Operating system Microsoft Windows, macOS, Linux
14 | Available in Scala, Java, SQL, Python, R, C#, F#
15 | Type Data analytics, machine learning algorithms
16 | License Apache License 2.0
17 | Website spark.apache.org Edit this at Wikidata
18 | Apache Spark is an open-source unified analytics engine for large-scale data processing. Spark provides an interface for programming entire clusters with implicit data parallelism and fault tolerance. Originally developed at the University of California, Berkeley's AMPLab, the Spark codebase was later donated to the Apache Software Foundation, which has maintained it since.
19 | ategories: Apache Software Foundation projectsBig data productsCluster computingData mining and machine learning softwareFree software programmed in ScalaHadoopJava platformSoftware using the Apache licenseUniversity of California, Berkeley
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code70_ClimbingStairs.java:
--------------------------------------------------------------------------------
1 | //假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
2 | //
3 | // 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
4 | //
5 | //
6 | //
7 | // 示例 1：
8 | //
9 | //
10 | //输入：n = 2
11 | //输出：2
12 | //解释：有两种方法可以爬到楼顶。
13 | //1. 1 阶 + 1 阶
14 | //2. 2 阶
15 | //
16 | // 示例 2：
17 | //
18 | //
19 | //输入：n = 3
20 | //输出：3
21 | //解释：有三种方法可以爬到楼顶。
22 | //1. 1 阶 + 1 阶 + 1 阶
23 | //2. 1 阶 + 2 阶
24 | //3. 2 阶 + 1 阶
25 | //
26 | //
27 | //
28 | //
29 | // 提示：
30 | //
31 | //
32 | // 1 <= n <= 45
33 | //
34 | // Related Topics 记忆化搜索 数学 动态规划 👍 2150 👎 0
35 |
36 | package leetcode.editor.cn;
37 |
38 | // 70.爬楼梯
39 | public class Code70_ClimbingStairs {
40 |
41 | //leetcode submit region begin(Prohibit modification and deletion)
42 | class Solution {
43 |
44 | public int climbStairs(int n) {
45 | if (n <= 2) {
46 | return n;
47 | }
48 |
49 | // dp[n]表示爬n级台阶的方法数
50 | int[] dp = new int[n + 1];
51 | dp[1] = 1;
52 | dp[2] = 2;
53 |
54 | for (int i = 3; i <= n; i++) {
55 | // 每次可以爬一阶或者两阶
56 | dp[i] = dp[i - 1] + dp[i - 2];
57 | }
58 | return dp[n];
59 | }
60 | }
61 | //leetcode submit region end(Prohibit modification and deletion)
62 |
63 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code31_NextPermutation.md:
--------------------------------------------------------------------------------
1 | 实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列（即，组合出下一个更大的整数）。
2 |
3 | 如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
4 |
5 | 必须 原地 修改，只允许使用额外常数空间。
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：nums = [1,2,3]
13 | 输出：[1,3,2]
14 |
15 |
16 | 示例 2：
17 |
18 |
19 | 输入：nums = [3,2,1]
20 | 输出：[1,2,3]
21 |
22 |
23 | 示例 3：
24 |
25 |
26 | 输入：nums = [1,1,5]
27 | 输出：[1,5,1]
28 |
29 |
30 | 示例 4：
31 |
32 |
33 | 输入：nums = [1]
34 | 输出：[1]
35 |
36 |
37 |
38 |
39 | 提示：
40 |
41 |
42 | 1 <= nums.length <= 1000 <= nums[i] <= 100
45 |
👍 1418👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code55_JumpGame.java:
--------------------------------------------------------------------------------
1 | //给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
2 | //
3 | // 数组中的每个元素代表你在该位置可以跳跃的最大长度。
4 | //
5 | // 判断你是否能够到达最后一个下标。
6 | //
7 | //
8 | //
9 | // 示例 1：
10 | //
11 | //
12 | //输入：nums = [2,3,1,1,4]
13 | //输出：true
14 | //解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
15 | //
16 | //
17 | // 示例 2：
18 | //
19 | //
20 | //输入：nums = [3,2,1,0,4]
21 | //输出：false
22 | //解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
23 | //
24 | //
25 | //
26 | //
27 | // 提示：
28 | //
29 | //
30 | // 1 <= nums.length <= 3 * 10⁴
31 | // 0 <= nums[i] <= 10⁵
32 | //
33 | // Related Topics 贪心 数组 动态规划 👍 1502 👎 0
34 |
35 | package leetcode.editor.cn;
36 |
37 | // 55.跳跃游戏
38 | public class Code55_JumpGame {
39 |
40 | //leetcode submit region begin(Prohibit modification and deletion)
41 | class Solution {
42 |
43 | public boolean canJump(int[] nums) {
44 | // 前n-1和元素能跳到的最远位置
45 | int k = 0;
46 | for (int i = 0; i <= k; i++) {
47 | k = Math.max(k, i + nums[i]);
48 | if (k >= nums.length - 1) {
49 | return true;
50 | }
51 | }
52 | return false;
53 | }
54 | }
55 | //leetcode submit region end(Prohibit modification and deletion)
56 |
57 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 10- II_QingWaTiaoTaiJieWenTiLcof.java:
--------------------------------------------------------------------------------
1 | //一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
2 | //
3 | // 答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
4 | //
5 | // 示例 1：
6 | //
7 | // 输入：n = 2
8 | //输出：2
9 | //
10 | //
11 | // 示例 2：
12 | //
13 | // 输入：n = 7
14 | //输出：21
15 | //
16 | //
17 | // 示例 3：
18 | //
19 | // 输入：n = 0
20 | //输出：1
21 | //
22 | // 提示：
23 | //
24 | //
25 | // 0 <= n <= 100
26 | //
27 | //
28 | // 注意：本题与主站 70 题相同：https://leetcode-cn.com/problems/climbing-stairs/
29 | //
30 | //
31 | // Related Topics 记忆化搜索 数学 动态规划 👍 216 👎 0
32 |
33 | package leetcode.editor.cn;
34 |
35 | // 剑指 Offer 10- II.青蛙跳台阶问题
36 | class Code_Offer_QingWaTiaoTaiJieWenTiLcof {
37 |
38 | //leetcode submit region begin(Prohibit modification and deletion)
39 | class Solution {
40 |
41 | public int numWays(int n) {
42 | if (n == 0 || n == 1) {
43 | return 1;
44 | }
45 | int pre = 1, cur = 2;
46 | for (int i = 3; i <= n; i++) {
47 | int tmp = (pre + cur) % 1000_000_007;
48 | pre = cur;
49 | cur = tmp;
50 | }
51 | return cur;
52 | }
53 | }
54 | //leetcode submit region end(Prohibit modification and deletion)
55 |
56 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code110_BalancedBinaryTree.md:
--------------------------------------------------------------------------------
1 | 给定一个二叉树，判断它是否是高度平衡的二叉树。
2 |
3 | 本题中，一棵高度平衡二叉树定义为：
4 |
5 |
6 | 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
7 |
8 |
9 |
10 |
11 | 示例 1：
12 | 
13 |
14 | 输入：root = [3,9,20,null,null,15,7]
15 | 输出：true
16 |
17 |
18 | 示例 2：
19 | 
20 |
21 | 输入：root = [1,2,2,3,3,null,null,4,4]
22 | 输出：false
23 |
24 |
25 | 示例 3：
26 |
27 |
28 | 输入：root = []
29 | 输出：true
30 |
31 |
32 |
33 |
34 | 提示：
35 |
36 |
37 | - 树中的节点数在范围
[0, 5000] 内
38 | -104 <= Node.val <= 104
40 |
👍 819👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution78.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import com.data.entity.ListNode;
4 |
5 | // 剑指 Offer II 078. 合并排序链表
6 | public class Solution78 {
7 |
8 | public ListNode mergeKLists(ListNode[] lists) {
9 | return mergeLists(lists, 0, lists.length - 1);
10 | }
11 |
12 | // 合并list[left...right]链表
13 | private ListNode mergeLists(ListNode[] lists, int left, int right) {
14 | if (left == right) {
15 | return lists[left];
16 | }
17 | if (left > right) {
18 | return null;
19 | }
20 | int mid = (left + right) / 2;
21 | ListNode l1 = mergeLists(lists, left, mid);
22 | ListNode l2 = mergeLists(lists, mid + 1, right);
23 |
24 | return merge(l1, l2);
25 | }
26 |
27 | // 合并升序链表
28 | private ListNode merge(ListNode l1, ListNode l2) {
29 | ListNode dummyHead = new ListNode(0);
30 | ListNode pre = dummyHead;
31 |
32 | while (l1 != null && l2 != null) {
33 | if (l1.val <= l2.val) {
34 | pre.next = l1;
35 | l1 = l1.next;
36 | } else {
37 | pre.next = l2;
38 | l2 = l2.next;
39 | }
40 | pre = pre.next;
41 | }
42 | pre.next = l1 != null ? l1 : l2;
43 | return dummyHead.next;
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/com/data/offer02/code/Solution76.java:
--------------------------------------------------------------------------------
1 | package com.data.offer02.code;
2 |
3 | import javax.swing.plaf.nimbus.NimbusLookAndFeel;
4 |
5 | // 数组中第k大的数字
6 | public class Solution76 {
7 |
8 | public int findKthLargest(int[] nums, int k) {
9 | return find(nums, k, 0, nums.length - 1);
10 | }
11 |
12 | // 在数组nums[left,right]上寻找数组中第k大的数字
13 | private int find(int[] nums, int k, int left, int right) {
14 | if (left >= right) {
15 | return nums[left];
16 | }
17 | int mid = partition(nums, left, right);
18 | if (mid + 1 == k) {
19 | return nums[mid];
20 | } else if (mid + 1 < k) {
21 | return find(nums, k, mid + 1, right);
22 | } else {
23 | return find(nums, k, left, mid - 1);
24 | }
25 | }
26 |
27 | // 分区:降序排序
28 | private int partition(int[] nums, int left, int right) {
29 | int cur = nums[right];
30 | int i = left;
31 | for (int j = left; j < right; j++) {
32 | if (nums[j] >= cur) {
33 | swap(nums, i, j);
34 | i++;
35 | }
36 | }
37 | swap(nums, i, right);
38 | return i;
39 | }
40 |
41 | private void swap(int[] nums, int i, int j) {
42 | int tmp = nums[i];
43 | nums[i] = nums[j];
44 | nums[j] = tmp;
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code188_BestTimeToBuyAndSellStockIv.md:
--------------------------------------------------------------------------------
1 | 给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
2 |
3 | 设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
4 |
5 | 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
6 |
7 |
8 |
9 | 示例 1：
10 |
11 |
12 | 输入：k = 2, prices = [2,4,1]
13 | 输出：2
14 | 解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
15 |
16 | 示例 2：
17 |
18 |
19 | 输入：k = 2, prices = [3,2,6,5,0,3]
20 | 输出：7
21 | 解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
22 | 随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
23 |
24 |
25 |
26 | 提示：
27 |
28 |
29 | 0 <= k <= 1000 <= prices.length <= 10000 <= prices[i] <= 1000
33 |
👍 651👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer 28_DuiChengDeErChaShuLcof.md:
--------------------------------------------------------------------------------
1 | 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
2 |
3 | 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
4 |
5 | 1
6 | / \
7 | 2 2
8 | / \ / \
9 | 3 4 4 3
10 | 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
11 |
12 | 1
13 | / \
14 | 2 2
15 | \ \
16 | 3 3
17 |
18 |
19 |
20 | 示例 1：
21 |
22 | 输入：root = [1,2,2,3,4,4,3]
23 | 输出：true
24 |
25 |
26 | 示例 2：
27 |
28 | 输入：root = [1,2,2,null,3,null,3]
29 | 输出：false
30 |
31 |
32 |
33 | 限制：
34 |
35 | 0 <= 节点个数 <= 1000
36 |
37 | 注意：本题与主站 101 题相同：https://leetcode-cn.com/problems/symmetric-tree/
38 | Related Topics
树深度优先搜索广度优先搜索二叉树
👍 265👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/Code剑指 Offer 42_LianXuZiShuZuDeZuiDaHeLcof.java:
--------------------------------------------------------------------------------
1 | //输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
2 | //
3 | // 要求时间复杂度为O(n)。
4 | //
5 | //
6 | //
7 | // 示例1:
8 | //
9 | // 输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
10 | //输出: 6
11 | //解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
12 | //
13 | //
14 | //
15 | // 提示：
16 | //
17 | //
18 | // 1 <= arr.length <= 10^5
19 | // -100 <= arr[i] <= 100
20 | //
21 | //
22 | // 注意：本题与主站 53 题相同：https://leetcode-cn.com/problems/maximum-subarray/
23 | //
24 | //
25 | // Related Topics 数组 分治 动态规划 👍 425 👎 0
26 |
27 | package leetcode.editor.cn;
28 |
29 | // 剑指 Offer 42.连续子数组的最大和
30 | class Code_Offer_LianXuZiShuZuDeZuiDaHeLcof {
31 |
32 | //leetcode submit region begin(Prohibit modification and deletion)
33 | class Solution {
34 |
35 | public int maxSubArray(int[] nums) {
36 | int n = nums.length;
37 | // dp[i]表示从0到i位置，连续子数组的最大和
38 | int[] dp = new int[n];
39 | dp[0] = nums[0];
40 | int ans = dp[0];
41 | for (int i = 1; i < n; i++) {
42 | dp[i] = Math.max(dp[i - 1] + nums[i], nums[i]);
43 | ans = Math.max(ans, dp[i]);
44 | }
45 | return ans;
46 | }
47 | }
48 | //leetcode submit region end(Prohibit modification and deletion)
49 |
50 | }
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code剑指 Offer II 014_MPnaiL.md:
--------------------------------------------------------------------------------
1 | 给定两个字符串 s1 和 s2，写一个函数来判断 s2 是否包含 s1 的某个变位词。
2 |
3 | 换句话说，第一个字符串的排列之一是第二个字符串的 子串 。
4 |
5 |
6 |
7 | 示例 1：
8 |
9 |
10 | 输入: s1 = "ab" s2 = "eidbaooo"
11 | 输出: True
12 | 解释: s2 包含 s1 的排列之一 ("ba").
13 |
14 |
15 | 示例 2：
16 |
17 |
18 | 输入: s1= "ab" s2 = "eidboaoo"
19 | 输出: False
20 |
21 |
22 |
23 |
24 | 提示：
25 |
26 |
27 | 1 <= s1.length, s2.length <= 104s1 和 s2 仅包含小写字母
30 |
31 |
32 |
33 | 注意：本题与主站 567 题相同： https://leetcode-cn.com/problems/permutation-in-string/
34 | Related Topics
哈希表双指针字符串滑动窗口
👍 25👎 0
--------------------------------------------------------------------------------
/algorithm/src/main/java/leetcode/editor/cn/doc/content/Code2_AddTwoNumbers.md:
--------------------------------------------------------------------------------
1 | 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
2 |
3 | 请你将两个数相加，并以相同形式返回一个表示和的链表。
4 |
5 | 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
6 |
7 |
8 |
9 | 示例 1：
10 | 
11 |
12 | 输入：l1 = [2,4,3], l2 = [5,6,4]
13 | 输出：[7,0,8]
14 | 解释：342 + 465 = 807.
15 |
16 |
17 | 示例 2：
18 |
19 |
20 | 输入：l1 = [0], l2 = [0]
21 | 输出：[0]
22 |
23 |
24 | 示例 3：
25 |
26 |
27 | 输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
28 | 输出：[8,9,9,9,0,0,0,1]
29 |
30 |
31 |
32 |
33 | 提示：
34 |
35 |
36 | - 每个链表中的节点数在范围
[1, 100] 内
37 | 0 <= Node.val <= 9- 题目数据保证列表表示的数字不含前导零
39 |
40 |
👍 7058👎 0
--------------------------------------------------------------------------------