repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution62.java | data_struct_study/src/dynamic_problem/Solution62.java | package dynamic_problem;
import java.util.Arrays;
/**
* 不同路径：要么【用数学递推公式】，
*
* 要么就根据定义【直接计算】。直接计算时需要注意
*
* Java “/”的整除性质，溢出，乘除顺序。
*/
public class Solution62 {
public int uniquePaths(int m, int n) {
int[] dp = new int[n];
Arrays.fill(dp, 1);
for (int i = 1; i < m; i++) {
for (int j = 1; j < n; j++) {
dp[j] = dp[j] + dp[j - 1];
}
}
return dp[n - 1];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution64.java | data_struct_study/src/dynamic_problem/Solution64.java | package dynamic_problem;
/**
* 最小路径和：其实到达某点的最小路径，只与该点数值、到达该点左边
* 的最小路径、到达该点上边的最小路径有关。所以只要找到
* 【正确循环顺序】，就可以避免所有的中间储存，两层循环即可。
*/
public class Solution64 {
public int minPathSum(int[][] grid) {
if (grid == null || grid.length == 0 || grid[0].length == 0) {
return 0;
}
int m = grid.length;
int n = grid[0].length;
int[] dp = new int[n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (j == 0) {
// 只能从上侧走到该位置
dp[j] = dp[j];
} else if (i == 0) {
// 只能从左侧走到该位置
dp[j] = dp[j - 1];
} else {
dp[j] = Math.min(dp[j], dp[j - 1]);
}
dp[j] += grid[i][j];
}
}
return dp[n - 1];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution1143.java | data_struct_study/src/dynamic_problem/Solution1143.java | package dynamic_problem;
import java.util.Arrays;
/**
* 题目描述：给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。
* 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的
* 情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
* 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。
* 两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
* 若这两个字符串没有公共子序列，则返回 0。
*
* 1、记忆化数组 + 递归（自上而下）
* 时间复杂度：O((len(s1) * len(s2))
* 空间复杂度：O((len(s1) * len(s2))
*/
public class Solution1143 {
private int[][] memo;
// 1、记忆化数组 + 递归（自上而下）
public int longestCommonSubsequence(String s1, String s2) {
// 1、如果s1或s2等于null，则抛出异常，等于0则直接返回0
if (s1 == null || s2 == null) {
throw new IllegalArgumentException("illegal arguments");
}
int n1 = s1.length();
int n2 = s2.length();
if (n1 == 0 || n2 == 0) {
return 0;
}
// 2、创建记忆数组并初始化第一维数组下标都为-1
memo = new int[n1][n2];
for (int i = 0; i < n1; i++) {
Arrays.fill(memo[i], -1);
}
// 3、递归计算 [0...m] 与 [0...n] 的最长公共子序列的长度
return lcs(s1, s2, n1 - 1, n2 - 1);
}
private int lcs(String s1, String s2, int m, int n) {
// 1）、如果m或n小于0，则返回0
if (m < 0 || n < 0) {
return 0;
}
// 2）、如果memo当前位置不等于-1表明已计算过，则直接返回
if (memo[m][n] != - 1) {
return memo[m][n];
}
// 3）、创建返回变量res，如果s1的m位置字符等于s2的n位置字符，
// 则res加1并继续递归计算m与n低一层级的lcs，
// 否则，取m低一层级与n低一层级中递归lcs的最大值
int res;
if (s1.charAt(m) == s2.charAt(n)) {
res = 1 + lcs(s1, s2, m - 1, n - 1);
} else {
res = Math.max(lcs(s1, s2, m - 1, n),
lcs(s1, s2, m , n - 1));
}
return memo[m][n] = res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution416_2.java | data_struct_study/src/dynamic_problem/Solution416_2.java | package dynamic_problem;
/**
* O(n * sum)
* O(n * sum)
*/
public class Solution416_2 {
public boolean canPartition(int[] nums) {
// 1、判断 nums 数组的和是否为偶数
int n = nums.length;
int sum = 0;
for (int i = 0; i < n; i++) {
if (nums[i] <= 0) {
throw new IllegalArgumentException("illegal argument!");
}
sum += nums[i];
}
if (sum % 2 == 1) {
return false;
}
int C = sum / 2;
// 2、创建 memo 记忆化数组，并同步 nums 数组的第一个元素的状态为 true
boolean[] memo = new boolean[C + 1];
for (int i = 0; i <= C; i++) {
memo[i] = (nums[0] == i);
}
// 3、使用背包状态转移方程
for (int i = 1; i < n; i++) {
for (int j = C; j >= nums[i]; j--) {
memo[j] = memo[j] || memo[j - nums[i]];
}
}
return memo[C];
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution221.java | data_struct_study/src/dynamic_problem/Solution221.java | package dynamic_problem;
/**
* 最大正方形：可以用动态规划，以某点为右下角的最大正方形边长 只与
* 以该点上面、左边、左上相邻点为右下角的最大正方形边长有关，
* 取最小+1的关系。用二维数组储存结果需要补充上边和左边的
* 数组 2d dp，也可以用一位数组储存结果，更节约空间 1d dp。
*/
public class Solution221 {
public int maximalSquare(char[][] matrix) {
int row = matrix.length;
int col = matrix.length==0? 0:matrix[0].length;
int[] dp = new int[col+1];
int ans = 0;
for (int i = 1; i < row+1; i++){
int prev = 0;
for (int j = 1; j < col+1; j++){
int temp = dp[j];
if (matrix[i-1][j-1]=='1'){
dp[j] = Math.min(Math.min(dp[j-1],dp[j]),prev)+1;
ans = Math.max(ans,dp[j]);
} else {dp[j] = 0;}
prev = temp;
}
}
return ans*ans;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution1143_2.java | data_struct_study/src/dynamic_problem/Solution1143_2.java | package dynamic_problem;
/**
* 2、记忆化数组 + DP（自下而上）：躲避边界条件
* 时间复杂度：O((len(s1) * len(s2))
* 空间复杂度：O((len(s1) * len(s2))
*/
public class Solution1143_2 {
// 2、记忆化数组 + DP（自下而上）：躲避边界条件
public int longestCommonSubsequence(String s1, String s2) {
// 1、如果s1或s2等于null，则抛出异常
if (s1 == null || s2 == null) {
throw new IllegalArgumentException("illegal argument!");
}
// 2、初始化记忆数组，注意这里的容量为len+1，
// 为了便于计算，后面的统计位置从下标1开始
int m = s1.length();
int n = s2.length();
int[][] memo = new int[m + 1][n + 1];
// 3、双层for循环：都从下标1开始，如果s1的i-1位置字符等于s2的j-1位置字符，
// 则当前位置memo取1+低一层级memo值，
// 否则，取m低一层级与n低一层级memo中的最大值
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
memo[i][j] = 1 + memo[i - 1][j - 1];
} else {
memo[i][j] = Math.max(memo[i - 1][j], memo[i][j - 1]);
}
}
}
return memo[m][n];
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution70.java | data_struct_study/src/dynamic_problem/Solution70.java | package dynamic_problem;
import java.util.Arrays;
/**
* 1、记忆化搜索 + 递归（自上而下）
* 时间复杂度：O(n)
* 空间复杂度：O(n)
*/
public class Solution70 {
private int[] memo;
// 1、记忆化搜索 + 递归（自上而下）
// 时间复杂度：O(n)，空间复杂度：O(n)
public int climbStairs(int n) {
// 1、创建记忆数组避免重复运算
memo = new int[n + 1];
Arrays.fill(memo, -1);
// 2、递归计算
return calcWays(n);
}
private int calcWays(int n) {
// 1）、如果楼梯为0或1层，则只有1种方式
if (n == 0 || n == 1) {
return 1;
}
// 2）、如果记忆数组中没有存储当前楼梯爬的方式个数，
// 则使用动态转移方程计算并保存在记忆数组中
if (memo[n] == -1) {
memo[n] = calcWays(n - 1) + calcWays(n - 2);
}
return memo[n];
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution279.java | data_struct_study/src/dynamic_problem/Solution279.java | package dynamic_problem;
import java.util.ArrayList;
import java.util.List;
public class Solution279 {
public int numSquare(int n) {
List<Integer> squareList = generateSquareList(n);
int[] dp = new int[n + 1];
for (int i = 1; i <= n; i++) {
int min = Integer.MAX_VALUE;
for (int square:squareList) {
if (i >= square) {
min = Math.max(min, dp[i - square] + 1);
}
}
dp[i] = min;
}
return dp[n];
}
private List<Integer> generateSquareList(int n) {
List<Integer> squareList = new ArrayList<>();
int square = 1;
int diff = 3;
while (square <= n) {
squareList.add(square);
square += diff;
diff += 2;
}
return squareList;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution53.java | data_struct_study/src/dynamic_problem/Solution53.java | package dynamic_problem;
/*
LeetCode Problem No.53: https://leetcode.com/problems/maximum-subarray/
Idea: maxEndingHere, maxSoFar -> compare from the end of subarray instead of beginning
Time: 1 ms, beat 99.96%
Space: 39.5MB, beat 71.04%
*/
class Solution53 {
// 一次循环，maxEndingHere储存以该点结尾的子序和，maxSoFar储存到该点的最大子序和。
public int maxSubArray(int[] nums) {
if (nums.length==0) return 0;
if (nums.length==1) return nums[0];
int maxEndingHere = nums[0];
int maxSoFar = nums[0];
for (int i = 1; i<nums.length; i++){
maxEndingHere = Math.max(nums[i],nums[i]+maxEndingHere);
maxSoFar = Math.max(maxSoFar, maxEndingHere);
}
return maxSoFar;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution198_5.java | data_struct_study/src/dynamic_problem/Solution198_5.java | package dynamic_problem;
import java.util.Arrays;
/**
* 记忆化搜索：优化状态转移
* O(n)
* O(n)
*/
public class Solution198_5 {
private int[] memo;
public int rob(int[] nums) {
memo = new int[nums.length];
Arrays.fill(memo, -1);
return tryRob(nums, 0);
}
private int tryRob(int[] nums, int index) {
if (index >= nums.length) {
return 0;
}
if (memo[index] != -1) {
return memo[index];
}
// 放弃当前房子抢劫下一个房子 或 抢劫当前房子考虑下下个房子
return memo[index] =
Math.max(tryRob(nums, index + 1),
nums[index] + tryRob(nums, index + 2));
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution198_7.java | data_struct_study/src/dynamic_problem/Solution198_7.java | package dynamic_problem;
import java.util.Arrays;
/**
* 记忆化搜索：改变状态定义，优化转移方程
* O(n)
* O(n)
*/
public class Solution198_7 {
private int[] memo;
public int rob(int[] nums) {
memo = new int[nums.length];
Arrays.fill(memo, -1);
return tryRob(nums, nums.length - 1);
}
private int tryRob(int[] nums, int index) {
if (index < 0) {
return 0;
}
if (memo[index] != -1) {
return memo[index];
}
// 放弃当前房子考虑抢劫下一个房子 或 抢劫当前房子考虑下下一个房子
return memo[index] = Math.max(tryRob(nums, index + 1),
nums[index] + tryRob(nums, index + 2));
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution509_2.java | data_struct_study/src/dynamic_problem/Solution509_2.java | package dynamic_problem;
import java.util.Arrays;
/**
* 记忆化搜索 + 递归
*/
public class Solution509_2 {
private int[] memo;
public int fib(int n) {
memo = new int[n + 1];
Arrays.fill(memo, -1);
return fib(n, memo);
}
private int fib(int n, int[] memo) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
if (memo[n] == -1) {
memo[n] = fib(n - 1, memo) + fib(n - 2, memo);
}
return memo[n];
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution.java | data_struct_study/src/dynamic_problem/Solution.java | package dynamic_problem;
/**
* 背包问题
* 记忆化搜索 => DP => DP + 滚动数组 => DP + 优化状态转移方程
* O(n * C)
* O(C)
*/
public class Solution {
public int knapsack(int[] w, int[] v, int C){
if (w == null || v == null || w.length != v.length) {
throw new IllegalArgumentException("illegal argument!");
}
if (C < 0) {
throw new IllegalArgumentException("C is illegal");
}
int n = w.length;
if (n == 0 || C == 0) {
return 0;
}
int[] memo = new int[C + 1];
for (int i = 0; i <= C; i++) {
memo[i] = (i > w[0] ? v[0] : 0);
}
for (int i = 0; i < n; i++) {
for (int j = C; j > w[i]; j--) {
memo[j] = Math.max(memo[j], v[i] + memo[j - w[i]]);
}
}
return memo[C];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution121.java | data_struct_study/src/dynamic_problem/Solution121.java | package dynamic_problem;
/**
* 题目描述：
* 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
* 如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），
* 设计一个算法来计算你所能获取的最大利润。
*
* 1、穷举框架-状态与选择：
* for 状态1 in 状态1的所有取值：
* for 状态2 in 状态2的所有取值：
* for ...
* dp[状态1][状态2][...] = 择优(选择1，选择2...)
* 这里每天都有三种「选择」：买入、卖出、无操作。
* 「状态」有三个，第一个是天数，第二个是允许交易的最大次数，第三个是当前的持有状态（0、1）
* 2、状态转移框架与 base case：
* 状态转移方程：
* dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
* dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
*
* base case：
* dp[-1][k][0] = dp[i][0][0] = 0
* dp[-1][k][1] = dp[i][0][1] = -infinity
*/
public class Solution121 {
// 时间复杂度：O(n), 空间复杂度：O(1)
public int maxProfit_k_1(int[] prices) {
// 1、初始化第i天未持有为0，第i天持有为负无穷
int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
// 2、遍历价格数组
for (int price : prices) {
// 1）、当天未持有等于 前一天未持有和前天持有+当天价格 中的最大值
dp_i_0 = Math.max(dp_i_0, dp_i_1 + price);
// 2）、当天持有等于 前一天持有和第一天未持有（0）-当前价格 中的最大值
dp_i_1 = Math.max(dp_i_1, -price);
}
// 3、返回最后一天未持有的价格
return dp_i_0;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution70_2.java | data_struct_study/src/dynamic_problem/Solution70_2.java | package dynamic_problem;
import java.util.Arrays;
/**
* 2、记忆化搜索 + DP（自下而上）
* 时间复杂度：O(n)
* 空间复杂度：O(n)
*/
public class Solution70_2 {
// 2、记忆化搜索 + DP（自下而上）
// 时间复杂度：O(n), 空间复杂度：O(n)
public int climbStairs(int n) {
// 1、创建记忆数组并全部填充为-1
int[] memo = new int[n + 1];
Arrays.fill(memo, -1);
// 2、第0或1层的爬楼梯方式都为1种
memo[0] = 1;
memo[1] = 1;
// 3、使用DP自下而上的方式计算目前楼层的爬楼梯方式
for (int i = 2; i <= n; i++) {
memo[i] = memo[i - 1] + memo[i - 2];
}
return memo[n];
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution322.java | data_struct_study/src/dynamic_problem/Solution322.java | package dynamic_problem;
import java.util.Arrays;
public class Solution322 {
public int coinChange(int[] coins, int amount) {
int max = amount + 1;
int[] dp = new int[amount + 1];
Arrays.fill(dp, max);
dp[0] = 0;
for (int i = 1; i <= amount; i++) {
for (int j = 0; j < coins.length; j++) {
if (coins[j] <= i) {
dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
}
}
}
return dp[amount] > amount ? -1 : dp[amount];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution494_2.java | data_struct_study/src/dynamic_problem/Solution494_2.java | package dynamic_problem;
public class Solution494_2 {
public int findTargetSumWays(int[] nums, int S) {
return findTargetSumWays(nums, 0, S);
}
private int findTargetSumWays(int[] nums, int start, int s) {
if (start == nums.length) {
return s == 0 ? 1 : 0;
}
return findTargetSumWays(nums, start + 1, s + nums[start]) +
findTargetSumWays(nums, start + 1, s - nums[start]);
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution343.java | data_struct_study/src/dynamic_problem/Solution343.java | package dynamic_problem;
/**
* 发现重叠的子问题
* 1、暴力解法：回溯遍历将一个树做分割的所有可能性。
* 2、记忆化搜索
* 2、动态规划。
* O(n ^ n)
* O(n)
*/
public class Solution343 {
public int integerBreak(int n) {
if (n < 1) {
throw new IllegalArgumentException("n is illegal argument");
}
return breakInteger(n);
}
private int breakInteger(int n) {
if (n == 1) {
return 1;
}
int res = -1;
for (int i = 1; i < n; i++) {
res = max3(res, i * (n - i), i * breakInteger(n - i));
}
return res;
}
private int max3(int a, int b, int c) {
return Math.max(a, Math.max(b, c));
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution239.java | data_struct_study/src/dynamic_problem/Solution239.java | package dynamic_problem;
import java.util.ArrayList;
import java.util.PriorityQueue;
public class Solution239 {
public ArrayList<Integer> maxInWindows(int[] num, int size) {
ArrayList<Integer> ret = new ArrayList<>();
if (size > num.length || size < 1)
return ret;
PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1); /* 大顶堆 */
for (int i = 0; i < size; i++)
heap.add(num[i]);
ret.add(heap.peek());
for (int i = 0, j = i + size; j < num.length; i++, j++) { /* 维护一个大小为 size 的大顶堆 */
heap.remove(num[i]);
heap.add(num[j]);
ret.add(heap.peek());
}
return ret;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution309.java | data_struct_study/src/dynamic_problem/Solution309.java | package dynamic_problem;
/**
* 最佳买卖股票时机含冷冻期: 重点在于【状态划分】，我们要确保这样
* 的状态划分保证每一笔交易都有冷冻期。
*
* sold：在当天卖出股票，必须由hold状态而来。 hold：当天持有股票，
* 可能是当天买入，或者之前买入的。可以由rest或者hold状态而来。
* rest：当天不持有股票，可能是前一天卖出的，也可能是更早卖出的。
* 可以由sold或者rest状态而来。 这样的状态划分，我们可以看到，
* 要从sold状态进入hold状态必须经过至少一次的rest，这就满足了
* 冷冻期的要求。需要注意的是初始值的选取，可以通过对第一天情况
* 代入来选取。这里sold选取的是0，但实际上只要取一个非负数就好。
*/
public class Solution309 {
public int maxProfit(int[] prices) {
int hold = Integer.MIN_VALUE;
int sold = 0;
int rest = 0;
for (int price : prices){
int pre = sold;
sold = hold + price;
hold = Math.max(hold,rest-price);
rest = Math.max(pre,rest);
}
return Math.max(sold,rest);
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution474.java | data_struct_study/src/dynamic_problem/Solution474.java | package dynamic_problem;
public class Solution474 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution198_2.java | data_struct_study/src/dynamic_problem/Solution198_2.java | package dynamic_problem;
/**
* DP
* O(n^2)
* O(n)
*/
public class Solution198_2 {
public int rob(int[] nums) {
int len = nums.length;
if (len == 0) {
return 0;
}
int[] memo = new int[len];
memo[len - 1] = nums[len - 1];
for (int i = len - 2; i >= 0; i--) {
for (int j = i; j < len; j++) {
nums[i] = Math.max(memo[i], nums[j] +
(j + 2 < len ? memo[j + 2] : 0));
}
}
return memo[0];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution300.java | data_struct_study/src/dynamic_problem/Solution300.java | package dynamic_problem;
import java.util.Arrays;
/**
* 题目描述：给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
* 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。
* 例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。
*
* 最长上升子序列:
* 1、暴力解法：选择所有的子序列进行判断。O((2^n)*n)
* 2、LIS(i) 表示[0...i]的范围内，选择数字nums[i]可以获得的最长上升子序列的长度。
* LIS(i) = max(1+LIS(j) if nums[i] > nums[j])
* LIS(i) 表示以第i个数字为结尾的最长上升子序列的长度。O(n^2）
* 3、O(nlogn)
*
* 记忆化搜索
* 时间复杂度：O(n^2)
* 空间复杂度：O(n)
*/
public class Solution300 {
private int[] memo;
public int lengthOfLIS(int[] nums) {
// 1、异常处理：如果数组长度等于0，则返回0
if (nums.length == 0) {
return 0;
}
// 2、创建记忆数组并全部填充为-1
memo = new int[nums.length];
Arrays.fill(memo, -1);
// 3、创建返回变量res，然后在for循环中不断计算当前位置的LIS
int res = 1;
for (int i = 0; i < nums.length; i++) {
res = Math.max(res, getMaxLength(nums, i));
}
return res;
}
// 4、记录以 nums[index] 为结尾的最长上升子序列的长度
private int getMaxLength(int[] nums, int index) {
// 1）、如果记忆数组中的当前位置不等于-1，则返回记忆值
if (memo[index] != -1) {
return memo[index];
}
// 2）、创建返回变量res，然后遍历到index-1处的位置：
// 如果index处的值大于前面位置i的值，则重新计算当前的res为
// res 与 1+i处位置的LIS 中的最大值
int res = 1;
for (int i = 0; i <= index - 1; i++) {
if (nums[index] > nums[i]) {
res = Math.max(res, 1 + getMaxLength(nums, i));
}
}
// 3）、保存index处的LIS并返回
return memo[index] = res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution376.java | data_struct_study/src/dynamic_problem/Solution376.java | package dynamic_problem;
/**
* 最长公共子序列 LCS
* 1、LCS(m, n) S1[0...m] 和 S2[0...n] 的最长公共子序列的长度。
* S1[m] == S2[n]: LCS(m, n) = 1 + LCS(m-1, n-1)
* S1[m] != S2[n]: LCS(m, n) = max( LCS(m-1, n), LCS(m, n-1))
*
* dijkstra 单源最短路径算法也是动态规划
* 1、shortestPath(i) 为从start到i的最短路径长度。
* shortestPath(x) = min(shortestPath(a) + w(a->x))
*/
public class Solution376 {
public int wiggleMaxLength(int[] nums) {
if (nums == null || nums.length == 0) {
return 0;
}
// 设立一个 up 和 down 变量
int up = 1, down = 1;
for (int i = 1; i < nums.length; i++) {
if (nums[i] > nums[i - 1]) {
up = down + 1;
} else if (nums[i] < nums[i - 1]) {
down = up + 1;
}
}
return Math.max(up, down);
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution343_3.java | data_struct_study/src/dynamic_problem/Solution343_3.java | package dynamic_problem;
import java.util.Arrays;
/**
* dp + 记忆化搜索
* O(n ^ 2)
* O(n)
*/
public class Solution343_3 {
private int[] memo;
public int integerBreak(int n) {
if (n < 1) {
throw new IllegalArgumentException("n is illegal argument!");
}
memo = new int[n + 1];
Arrays.fill(memo, -1);
memo[1] = 1;
for (int i = 2; i <= n; i++) {
// 求解 memo[i]
for (int j = 1; j <= i - 1; j++) {
memo[i] = max3(memo[i], j * (i - j), j * memo[i - j]);
}
}
return memo[n];
}
private int max3(int a, int b, int c) {
return Math.max(a, Math.max(b, c));
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Main.java | data_struct_study/src/dynamic_problem/Main.java | package dynamic_problem;
/**
* 什么是动态规划？
* 斐波那契数列——解决递归中的 重叠子问题 && 最优子结构：通过求子问题的最优解，可以获得原问题的最优解：
* 1、记忆化搜索避免重复运算，自上而下的解决问题。
* 2、动态规划，自下而上的解决问题。
* 动态规划将是将原问题拆解成若干个子问题，同时保存子问题的答案，
* 使得每个子问题只求解一次，最终获得原问题的答案。
*
* JsonChao的动态规划核心题库：26题
*/
public class Main {
public static void main(String[] args) {
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution337.java | data_struct_study/src/dynamic_problem/Solution337.java | package dynamic_problem;
public class Solution337 {
public static class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public int rob(TreeNode root) {
if (root == null) {
return 0;
}
// 1、计算第 1、3...层节点的总值
int val1 = root.val;
if (root.left != null) {
val1 += rob(root.left.left) + rob(root.left.right);
}
if (root.right != null) {
val1 += rob(root.right.left) + rob(root.right.right);
}
int val2 = rob(root.left) + rob(root.right);
return Math.max(val1, val2);
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution72.java | data_struct_study/src/dynamic_problem/Solution72.java | package dynamic_problem;
/**
* 动态规划给出具体解
* 反向求出具体的解，甚至是所有的解。
* 编辑距离 72
*/
public class Solution72 {
public int minDistance(String word1, String word2) {
// 1、创建 dp 数组并赋值上边界和左边界
if (word1 == null || word2 == null) {
return 0;
}
int m = word1.length();
int n = word2.length();
// 注意
int[][] dp = new int[m + 1][n + 1];
for (int i = 1; i <= m; i++) {
dp[i][0] = i;
}
for (int i = 1; i <= n; i++) {
dp[0][i] = i;
}
// 2、处理编辑距离
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1];
} else {
dp[i][j] = Math.min(dp[i - 1][j - 1], Math.min(dp[i - 1][j],
dp[i][j - 1])) + 1;
}
}
}
return dp[m][n];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution122.java | data_struct_study/src/dynamic_problem/Solution122.java | package dynamic_problem;
/**
* 题目描述：给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
* 设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
*
* 如果 k 为正无穷，那么就可以认为 k 和 k - 1 是一样的:
* dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
* dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
* = max(dp[i-1][k][1], dp[i-1][k][0] - prices[i])
*
* 我们发现数组中的 k 已经不会改变了，也就是说不需要记录 k 这个状态了：
* dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
* dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])
*
* 第三题，k = +infinity with cooldown
*
* 每次 sell 之后要等一天才能继续交易。只要把这个特点融入上一题的状态转移方程即可：
* dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
* dp[i][1] = max(dp[i-1][1], dp[i-2][0] - prices[i])
* 解释：第 i 天选择 buy 的时候，要从 i-2 的状态转移，而不是 i-1 。
*
* 第四题，k = +infinity with fee
*
* 每次交易要支付手续费，只要把手续费从利润中减去即可。改写方程：
*
* 第五题，k = 2
*
* 这里 k 取值范围比较小，所以可以不用 for 循环，直接把 k = 1 和 2 的情况全部列举出来也可以：
* dp[i][2][0] = max(dp[i-1][2][0], dp[i-1][2][1] + prices[i])
* dp[i][2][1] = max(dp[i-1][2][1], dp[i-1][1][0] - prices[i])
* dp[i][1][0] = max(dp[i-1][1][0], dp[i-1][1][1] + prices[i])
* dp[i][1][1] = max(dp[i-1][1][1], -prices[i])
*
* 第六题，k = any integer
*
* 一次交易由买入和卖出构成，至少需要两天。所以说有效的限制 k 应该不超过 n/2，如果超过，就没有约束作用了，相当于 k = +infinity。
*
* 关键就在于列举出所有可能的「状态」，然后想想怎么穷举更新这些「状态」。一般用一个多维 dp 数组储存这些状态，从 base case 开始向后推进，推进到最后的状态，就是我们想要的答案。想想这个过程，你是不是有点理解「动态规划」这个名词的意义了呢？
*
*/
public class Solution122 {
// 时间复杂度：O(n), 空间复杂度：O(1)
public int maxProfit_k_inf(int[] prices) {
// 1、初始化第i天未持有为0，第i天持有为负无穷
int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
// 2、遍历价格数组
for (int price : prices) {
// 1）、初始化temp变量记录前一天未持有的价格
int temp = dp_i_0;
// 2）、当天未持有等于 前一天未持有和前天持有+当天价格 中的最大值
dp_i_0 = Math.max(dp_i_0, dp_i_1 + price);
// 3）、当天持有等于 前一天持有和temp-当天价格 中的最大值
dp_i_1 = Math.max(dp_i_1, temp - price);
}
// 3、返回最后一天未持有的价格
return dp_i_0;
}
int maxProfit_with_cool(int[] prices) {
int n = prices.length;
int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
int dp_pre_0 = 0; // 代表 dp[i-2][0]
for (int price : prices) {
int temp = dp_i_0;
dp_i_0 = Math.max(dp_i_0, dp_i_1 + price);
dp_i_1 = Math.max(dp_i_1, dp_pre_0 - price);
dp_pre_0 = temp;
}
return dp_i_0;
}
int maxProfit_with_fee(int[] prices, int fee) {
int n = prices.length;
int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
for (int price : prices) {
int temp = dp_i_0;
dp_i_0 = Math.max(dp_i_0, dp_i_1 + price);
dp_i_1 = Math.max(dp_i_1, temp - price - fee);
}
return dp_i_0;
}
int maxProfit_k_2(int[] prices) {
int dp_i10 = 0, dp_i11 = Integer.MIN_VALUE;
int dp_i20 = 0, dp_i21 = Integer.MIN_VALUE;
for (int price : prices) {
dp_i20 = Math.max(dp_i20, dp_i21 + price);
dp_i21 = Math.max(dp_i21, dp_i10 - price);
dp_i10 = Math.max(dp_i10, dp_i11 + price);
dp_i11 = Math.max(dp_i11, -price);
}
return dp_i20;
}
int maxProfit_k_any(int max_k, int[] prices) {
int n = prices.length;
if (max_k > n / 2)
return maxProfit_k_inf(prices);
int[][][] dp = new int[n][max_k + 1][2];
for (int i = 0; i < n; i++)
for (int k = max_k; k >= 1; k--) {
if (i - 1 == -1) { /* 处理 base case */ }
dp[i][k][0] = Math.max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
dp[i][k][1] = Math.max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]);
}
return dp[n - 1][max_k][0];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution494.java | data_struct_study/src/dynamic_problem/Solution494.java | package dynamic_problem;
/**
* 目标和：一个朴素的想法是用【暴力破解】 ，枚举所有的正负组合方式，
* 对每一次结果进行筛选，但是这样就超时了。这样的暴力破解法也可以
* 写成【递归】 的形式（会导致一部分不可避免的重复运算）。
* 但其实呢，我们可以把所有的数分为两部分，第一部分用加号，
* 第二部分用减号，由此可以得出用加号部分的和。问题就被转
* 化成了 416. 分割等和子集 ，即寻找子集使得和为某一特定
* 数字，每一个数字仅能用1次。
*/
public class Solution494 {
public int findTargetSumWays(int[] nums, int S) {
// 1、计算数组和
int sum = countSum(nums);
if (sum < S || (sum + S) % 2 == 1) {
return 0;
}
int W = (sum + S) / 2;
int[] dp = new int[W + 1];
dp[0] = 1;
for (int num:nums) {
for (int i = W; i >= num; i--) {
dp[i] = dp[i] + dp[i - num];
}
}
return dp[W];
}
private int countSum(int[] nums) {
int res = 0;
for (int i:nums) {
res += i;
}
return res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution416.java | data_struct_study/src/dynamic_problem/Solution416.java | package dynamic_problem;
import java.util.Arrays;
/**
* 0-1背包问题
* 1、暴力解法：每一件物品都可以放进背包，也可以不放进背包。O((2^n)*n)
* 2、动态规范——状态转移方程：F(n, C) 考虑将n个物品放进容量为C的背包，使得价值最大。
* F(n, C) = max(F(i-1, c), v(i) + F(i-1, c - w(i))
* O(n*C) O(n*C)
* 3、优化：根据状态转移方程，第i行元素只依赖于第i-1行元素。理论上，只需要保持两行元素。
* 空间复杂度：O(2*C） = O(c)
* 4、优化加强：只使用一行大小为C的数组完成动态规划？
* 从后向前刷新当前 memo 中元素。
* 0-1背包问题的更多变种
* 1、完全背包问题：每个物品可以无限使用。
* 2、多重背包问题：每个物品不止1个，有num(i)个。
* 3、多维费用背包问题：要考虑物品的体积和重量两个维度？
* 4、物品间加入更多约束：物品间可以相互排斥或依赖。
*
* 416：
* 1、F(n, C) 考虑将n个物品填满容量为C的背包。
* 2、F(i, c) = F(i-1, c) || F(i-1, c-w(i))
* 3、时间复杂度：O(n*sum/2) = O(n*sum)
* 4、空间复杂度：O(n * sum)
*/
public class Solution416 {
private int[][] memo;
public boolean canPartition(int[] nums) {
// 1、判断 nums 数组的和是否为偶数
int sum = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] <= 0) {
throw new IllegalArgumentException("illegal argument!");
}
sum += nums[i];
}
if (sum % 2 == 1) {
return false;
}
// 2、创建 memo[i][C] 记忆化数组并初始化：-1 未计算 0 不能填充 1 可以填充
memo = new int[nums.length][sum / 2 + 1];
for (int i = 0; i < nums.length; i++) {
Arrays.fill(memo[i], -1);
}
return tryPartition(nums, nums.length - 1, sum / 2);
}
// 3、判断在 [0...index] 的数组范围中是否可以填充满 sum
private boolean tryPartition(int[] nums, int index, int sum) {
if (sum == 0) {
return true;
}
if (index < 0 || sum < 0) {
return false;
}
if (memo[index][sum] != -1) {
return memo[index][sum] == 1;
}
memo[index][sum] = (tryPartition(nums, index - 1, sum) ||
tryPartition(nums, index - 1, sum - nums[index])) ? 1 : 0;
return memo[index][sum] == 1;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/dynamic_problem/Solution91.java | data_struct_study/src/dynamic_problem/Solution91.java | package dynamic_problem;
public class Solution91 {
public int numDecodings(String s) {
if (s == null || s.length() == 0) {
return 0;
}
// 1、预先处理 dp[0] 与 dp[1]
int n = s.length();
int[] dp = new int[n + 1];
dp[0] = 1;
dp[1] = s.charAt(0) == '0' ? 0 : 1;
for (int i = 2; i <= n; i++) {
// 2、累加前一个位数计算得到的值
int one = Integer.parseInt(s.substring(i - 1, i));
if (one != 0) {
dp[i] += dp[i - 1];
}
if (s.charAt(i - 2) == '0') {
continue;
}
// 3、计算当前位数需累加的值
int two = Integer.parseInt(s.substring(i - 2, i));
if (two <= 26) {
dp[i] += dp[i - 2];
}
}
return dp[n];
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/avl/FileOperation.java | data_struct_study/src/avl/FileOperation.java | package avl;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Locale;
import java.util.Scanner;
// 文件相关操作
public class FileOperation {
// 读取文件名称为filename中的内容，并将其中包含的所有词语放进words中
public static boolean readFile(String filename, ArrayList<String> words){
if (filename == null || words == null){
System.out.println("filename is null or words is null");
return false;
}
// 文件读取
Scanner scanner;
try {
File file = new File(filename);
if(file.exists()){
FileInputStream fis = new FileInputStream(file);
scanner = new Scanner(new BufferedInputStream(fis), "UTF-8");
scanner.useLocale(Locale.ENGLISH);
}
else
return false;
}
catch(IOException ioe){
System.out.println("Cannot open " + filename);
return false;
}
// 简单分词
// 这个分词方式相对简陋, 没有考虑很多文本处理中的特殊问题
// 在这里只做demo展示用
if (scanner.hasNextLine()) {
String contents = scanner.useDelimiter("\\A").next();
int start = firstCharacterIndex(contents, 0);
for (int i = start + 1; i <= contents.length(); )
if (i == contents.length() || !Character.isLetter(contents.charAt(i))) {
String word = contents.substring(start, i).toLowerCase();
words.add(word);
start = firstCharacterIndex(contents, i);
i = start + 1;
} else
i++;
}
return true;
}
// 寻找字符串s中，从start的位置开始的第一个字母字符的位置
private static int firstCharacterIndex(String s, int start){
for( int i = start ; i < s.length() ; i ++ )
if( Character.isLetter(s.charAt(i)) )
return i;
return s.length();
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/avl/AVLTree.java | data_struct_study/src/avl/AVLTree.java | package avl;
import java.util.ArrayList;
/**
* AVL 的自平衡机制：
* 1、左旋转
* 2、右旋转
*
* 在什么时候维护平衡？
* 加入节点后，沿着节点向上维护平衡性。
*
* 时间复杂度 O(logn)
*
* AVL 优化：在维护每一个节点之前，都需要对 AVL 的高度进行重新的计算，
* 但是如果我们重新计算出的这个节点的高度与原先的高度相等的话，对于这个
* 节点的祖先节点就不再需要维护平衡的操作了。这是因为这个节点的高度和原先
* 一样，从它的父亲节点和祖先节点来看，它的子树的高度并没有发送变化，
* 所以不需要维护平衡了。
*
* AVL 树的局限性：红黑树的旋转操作相对更少，性能更优一些。
*
* @param <K> key
* @param <V> value
*/
public class AVLTree<K extends Comparable<K>, V> {
private class Node{
public K key;
public V value;
public Node left, right;
public int height;
public Node(K key, V value){
this.key = key;
this.value = value;
left = null;
right = null;
height = 1;
}
}
private Node root;
private int size;
public AVLTree(){
root = null;
size = 0;
}
private int getHeight(Node node) {
if (node == null) {
return 0;
}
return node.height;
}
private int getBalanceFactory(Node node) {
if (node == null) {
return 0;
}
return getHeight(node.left) - getHeight(node.right);
}
public boolean isBSTTree() {
ArrayList<K> keys = new ArrayList<>();
inOrder(keys, root);
for (int i = 1; i < keys.size(); i++) {
if (keys.get(i - 1).compareTo(keys.get(i)) > 0) {
return false;
}
}
return true;
}
public boolean isBalance() {
return isBalance(root);
}
private boolean isBalance(Node node) {
if (node == null) {
return true;
}
int balanceFactory = getBalanceFactory(node);
if (Math.abs(balanceFactory) > 1) {
return false;
}
return isBalance(node.left) && isBalance(node.right);
}
/**
* BST 中序遍历后的数据时升序的
*/
private void inOrder(ArrayList<K> keys, Node node) {
if (node == null) {
return;
}
inOrder(keys, node.left);
keys.add(node.key);
inOrder(keys, node.right);
}
public int getSize(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
// 向二分搜索树中添加新的元素(key, value)
public void add(K key, V value){
root = add(root, key, value);
}
// 向以node为根的二分搜索树中插入元素(key, value)，递归算法
// 返回插入新节点后二分搜索树的根
private Node add(Node node, K key, V value){
if(node == null){
size ++;
return new Node(key, value);
}
if(key.compareTo(node.key) < 0)
node.left = add(node.left, key, value);
else if(key.compareTo(node.key) > 0)
node.right = add(node.right, key, value);
else // key.compareTo(node.key) == 0
node.value = value;
// 1、更新当前节点的高度
node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
// 2、记录不平衡的因子（如果有）
int balanceFactory = getBalanceFactory(node);
// 3、维护平衡
// LL，为保持平衡，进行右旋转
if (balanceFactory > 1 && getBalanceFactory(node.left) >= 0) {
return rightRotate(node);
}
// RR，为保持平衡，进行左旋转
if (balanceFactory < - 1 && getBalanceFactory(node.right) <= 0) {
return leftRotate(node);
}
// LR，为保持平衡，先对 node.left 进行左旋转转换为 LL，再对 node 进行右旋转
if (balanceFactory > 1 && getBalanceFactory(node.left) < 0) {
node.left = leftRotate(node.left);
return rightRotate(node);
}
// RL，为保持平衡，先对 node.right 进行右旋转转换为 RR，再对 node 进行左旋转
if (balanceFactory < -1 && getBalanceFactory(node.right) > 0) {
node.right = rightRotate(node.right);
return leftRotate(node);
}
return node;
}
/**
* RR，为保持平衡，进行左旋转.
* 对节点 y 进行向左旋转操作，返回旋转后新的根节点 x。
* y x
* / \ / \
* T1 x 向左旋转 (y) y z
* / \ - - - - - - - -> / \ / \
* T2 z T1 T2 T3 T4
* / \
* T3 T4
*
* @param y 不平衡节点
* @return 新的平衡节点 x
*/
private Node leftRotate(Node y) {
Node x = y.right;
Node T2 = x.left;
// 左旋转
x.left = y;
y.right = T2;
// 先后更新 y 和 x 的高度
y.height = 1 + Math.max(getHeight(y.left), getHeight(y.right));
x.height = 1 + Math.max(getHeight(x.left), getHeight(x.right));
return x;
}
/**
* LL，为保持平衡，进行右旋转。
* 对节点 y 进行向右旋转操作，返回旋转后新的根节点 x。
*
* y x
* / \ / \
* x T4 向右旋转 (y) z y
* / \ - - - - - - - -> / \ / \
* z T3 T1 T2 T3 T4
* / \
* T1 T2
* @param y 不平衡节点
* @return 新的平衡节点 x
*/
private Node rightRotate(Node y) {
Node x = y.left;
Node T3 = x.right;
// 右旋转
x.right = y;
y.left = T3;
// 先后更新 y 和 x 的高度
y.height = 1 + Math.max(getHeight(y.left), getHeight(y.right));
x.height = 1 + Math.max(getHeight(x.left), getHeight(x.right));
return x;
}
// 返回以node为根节点的二分搜索树中，key所在的节点
private Node getNode(Node node, K key){
if(node == null)
return null;
if(key.equals(node.key))
return node;
else if(key.compareTo(node.key) < 0)
return getNode(node.left, key);
else // if(key.compareTo(node.key) > 0)
return getNode(node.right, key);
}
public boolean contains(K key){
return getNode(root, key) != null;
}
public V get(K key){
Node node = getNode(root, key);
return node == null ? null : node.value;
}
public void set(K key, V newValue){
Node node = getNode(root, key);
if(node == null)
throw new IllegalArgumentException(key + " doesn't exist!");
node.value = newValue;
}
// 返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node){
if(node.left == null)
return node;
return minimum(node.left);
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// 从二分搜索树中删除键为key的节点
public V remove(K key){
Node node = getNode(root, key);
if(node != null){
root = remove(root, key);
return node.value;
}
return null;
}
private Node remove(Node node, K key){
if(node == null)
return null;
Node retNode;
if ( key.compareTo(node.key) < 0) {
node.left = remove(node.left , key);
retNode = node;
} else if (key.compareTo(node.key) > 0 ){
node.right = remove(node.right, key);
retNode = node;
} else { // key.compareTo(node.key) == 0
// 待删除节点左子树为空的情况
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
retNode = rightNode;
} else if (node.right == null) {
// 待删除节点右子树为空的情况
Node leftNode = node.left;
node.left = null;
size --;
retNode = leftNode;
} else {
// 待删除节点左右子树均不为空的情况
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node successor = minimum(node.right);
// successor.right = removeMin(node.right);
successor.right = remove(node.right, successor.key);
successor.left = node.left;
node.left = node.right = null;
retNode = successor;
}
}
if (retNode == null) {
return null;
}
// 1、更新当前节点的高度
retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
// 2、记录不平衡的因子（如果有）
int balanceFactory = getBalanceFactory(retNode);
// 3、维护平衡
// LL，为保持平衡，进行右旋转
if (balanceFactory > 1 && getBalanceFactory(retNode.left) >= 0) {
return rightRotate(retNode);
}
// RR，为保持平衡，进行左旋转
if (balanceFactory < - 1 && getBalanceFactory(retNode.right) <= 0) {
return leftRotate(retNode);
}
// LR，为保持平衡，先对 node.left 进行左旋转转换为 LL，再对 node 进行右旋转
if (balanceFactory > 1 && getBalanceFactory(retNode.left) < 0) {
node.left = leftRotate(retNode.left);
return rightRotate(retNode);
}
// RL，为保持平衡，先对 node.right 进行右旋转转换为 RR，再对 node 进行左旋转
if (balanceFactory < -1 && getBalanceFactory(retNode.right) > 0) {
retNode.right = rightRotate(retNode.right);
return leftRotate(retNode);
}
return retNode;
}
public static void main(String[] args){
System.out.println("Pride and Prejudice");
ArrayList<String> words = new ArrayList<>();
if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
System.out.println("Total words: " + words.size());
AVLTree<String, Integer> map = new AVLTree<>();
for (String word : words) {
if (map.contains(word))
map.set(word, map.get(word) + 1);
else
map.add(word, 1);
}
System.out.println("Total different words: " + map.getSize());
System.out.println("Frequency of PRIDE: " + map.get("pride"));
System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
System.out.println("is BST : " + map.isBSTTree());
System.out.println("is Balanced : " + map.isBalance());
for(String word: words){
map.remove(word);
if(!map.isBSTTree() || !map.isBalance())
throw new RuntimeException();
}
}
System.out.println();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/avl/BST.java | data_struct_study/src/avl/BST.java | package avl;
import java.util.ArrayList;
public class BST<K extends Comparable<K>, V> {
private class Node{
public K key;
public V value;
public Node left, right;
public Node(K key, V value){
this.key = key;
this.value = value;
left = null;
right = null;
}
}
private Node root;
private int size;
public BST(){
root = null;
size = 0;
}
public int getSize(){
return size;
}
public boolean isEmpty(){
return size == 0;
}
// 向二分搜索树中添加新的元素(key, value)
public void add(K key, V value){
root = add(root, key, value);
}
// 向以node为根的二分搜索树中插入元素(key, value)，递归算法
// 返回插入新节点后二分搜索树的根
private Node add(Node node, K key, V value){
if(node == null){
size ++;
return new Node(key, value);
}
if(key.compareTo(node.key) < 0)
node.left = add(node.left, key, value);
else if(key.compareTo(node.key) > 0)
node.right = add(node.right, key, value);
else // key.compareTo(node.key) == 0
node.value = value;
return node;
}
// 返回以node为根节点的二分搜索树中，key所在的节点
private Node getNode(Node node, K key){
if(node == null)
return null;
if(key.equals(node.key))
return node;
else if(key.compareTo(node.key) < 0)
return getNode(node.left, key);
else // if(key.compareTo(node.key) > 0)
return getNode(node.right, key);
}
public boolean contains(K key){
return getNode(root, key) != null;
}
public V get(K key){
Node node = getNode(root, key);
return node == null ? null : node.value;
}
public void set(K key, V newValue){
Node node = getNode(root, key);
if(node == null)
throw new IllegalArgumentException(key + " doesn't exist!");
node.value = newValue;
}
// 返回以node为根的二分搜索树的最小值所在的节点
private Node minimum(Node node){
if(node.left == null)
return node;
return minimum(node.left);
}
// 删除掉以node为根的二分搜索树中的最小节点
// 返回删除节点后新的二分搜索树的根
private Node removeMin(Node node){
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
node.left = removeMin(node.left);
return node;
}
// 从二分搜索树中删除键为key的节点
public V remove(K key){
Node node = getNode(root, key);
if(node != null){
root = remove(root, key);
return node.value;
}
return null;
}
private Node remove(Node node, K key){
if( node == null )
return null;
if( key.compareTo(node.key) < 0 ){
node.left = remove(node.left , key);
return node;
}
else if(key.compareTo(node.key) > 0 ){
node.right = remove(node.right, key);
return node;
}
else{ // key.compareTo(node.key) == 0
// 待删除节点左子树为空的情况
if(node.left == null){
Node rightNode = node.right;
node.right = null;
size --;
return rightNode;
}
// 待删除节点右子树为空的情况
if(node.right == null){
Node leftNode = node.left;
node.left = null;
size --;
return leftNode;
}
// 待删除节点左右子树均不为空的情况
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node successor = minimum(node.right);
successor.right = removeMin(node.right);
successor.left = node.left;
node.left = node.right = null;
return successor;
}
}
public static void main(String[] args){
System.out.println("Pride and Prejudice");
ArrayList<String> words = new ArrayList<>();
if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
System.out.println("Total words: " + words.size());
BST<String, Integer> map = new BST<>();
for (String word : words) {
if (map.contains(word))
map.set(word, map.get(word) + 1);
else
map.add(word, 1);
}
System.out.println("Total different words: " + map.getSize());
System.out.println("Frequency of PRIDE: " + map.get("pride"));
System.out.println("Frequency of PREJUDICE: " + map.get("prejudice"));
}
System.out.println();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/avl/Main.java | data_struct_study/src/avl/Main.java | package avl;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
System.out.println("Pride and Prejudice");
ArrayList<String> words = new ArrayList<>();
if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
System.out.println("Total words: " + words.size());
Collections.sort(words);
// Test BST
long startTime = System.nanoTime();
BST<String, Integer> bst = new BST<>();
for (String word : words) {
if (bst.contains(word))
bst.set(word, bst.get(word) + 1);
else
bst.add(word, 1);
}
for(String word: words)
bst.contains(word);
long endTime = System.nanoTime();
double time = (endTime - startTime) / 1000000000.0;
System.out.println("BST: " + time + " s");
// Test AVL Tree
startTime = System.nanoTime();
AVLTree<String, Integer> avl = new AVLTree<>();
for (String word : words) {
if (avl.contains(word))
avl.set(word, avl.get(word) + 1);
else
avl.add(word, 1);
}
for(String word: words)
avl.contains(word);
endTime = System.nanoTime();
time = (endTime - startTime) / 1000000000.0;
System.out.println("AVL: " + time + " s");
}
System.out.println();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution220.java | data_struct_study/src/hash_table_problem/Solution220.java | package hash_table_problem;
import java.util.TreeSet;
/**
* 220：
* 1、滑动窗口 + set.lower_bound，注意使用 long 运算，避免整形溢出。
*
* O(nlog(k)
* O(k)
*/
public class Solution220 {
public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
// 1、异常处理
if (nums == null || nums.length <= 1) {
return false;
}
if (k <= 0 || t < 0) {
return false;
}
TreeSet<Long> record = new TreeSet<>();
for (int i = 0; i < nums.length; i++) {
// 2、treeSet.lower_bound
if (record.ceiling((long)nums[i] - (long)t) != null &&
record.ceiling((long)nums[i] - (long)t) <= ((long)nums[i] + (long)t)) {
return true;
}
// 3、滑动窗口
record.add((long) nums[i]);
if (record.size() == k + 1) {
record.remove((long)nums[i - k]);
}
}
return false;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution202.java | data_struct_study/src/hash_table_problem/Solution202.java | package hash_table_problem;
/**
* 202：陷入循环就不是 happy number。
*/
public class Solution202 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution242.java | data_struct_study/src/hash_table_problem/Solution242.java | package hash_table_problem;
/**
* 242：
* 1、空集
* 2、字符集
*
* 可以用 HashMap 来映射字符与出现次数，然后比较两个字符串出现的字符数量是否相同。
*
* 由于本题的字符串只包含 26 个小写字符，因此可以使用长度为 26 的整型数组
* 对字符串出现的字符进行统计，不再使用 HashMap。
*/
public class Solution242 {
public boolean isAnagram(String s, String t) {
int[] countForNum = new int[26];
for(char c:s.toCharArray()) {
countForNum[c - 'a']++;
}
for (char c:t.toCharArray()) {
countForNum[c - 'a']--;
}
for (int count:countForNum) {
if (count != 0) {
return false;
}
}
return true;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution217.java | data_struct_study/src/hash_table_problem/Solution217.java | package hash_table_problem;
import java.util.HashSet;
import java.util.Set;
/**
* 219、217（简化版219）：
* 1、暴力枚举法：O(n^2)
* 2、滑动窗口 + 查找表：O(n) 空间 O(k)
*/
public class Solution217 {
public boolean containsDuplicate(int[] nums) {
Set<Integer> hashSet = new HashSet<>();
for (int num:nums) {
hashSet.add(num);
}
return hashSet.size() < nums.length;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution18.java | data_struct_study/src/hash_table_problem/Solution18.java | package hash_table_problem;
public class Solution18 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution1.java | data_struct_study/src/hash_table_problem/Solution1.java | package hash_table_problem;
import java.util.HashMap;
/**
* Two Sum 系列——1:
* 1、索引从0开始计算还是从1开始计算？
* 2、没有解怎么办？
* 3、有多个解怎么办？保证有唯一解。
* 4、暴力解法 O(n^2)
* 5、排序后，使用双索引对撞：O(nlogn) + O(n) = O(nlogn)
* 6、查找表(map)，将所有元素放入查找表，之后对每一个元素 a，查找 target - a 是否存在。O(n)
*/
public class Solution1 {
public int[] twoSum(int[] nums, int target) {
HashMap<Integer, Integer> record = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i];
if (record.containsKey(complement)) {
int[] res = {record.get(complement), i};
return res;
}
record.put(nums[i], i);
}
throw new IllegalArgumentException("no this array exist!");
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution349.java | data_struct_study/src/hash_table_problem/Solution349.java | package hash_table_problem;
import java.util.TreeSet;
/**
* 349（set）、350（map）：
* 1、C++ 中 map find 不到元素时输出 0
*
* set 和 map 不同底层实现的区别
* 普通数组实现 顺序数组实现 二分搜索树（平衡） 哈希表
* 插入 O(1) O(n) O(logn) O(1)
* 查找 O(n) O(logn) O(logn) O(1)
* 删除 O(n) O(n) O(logn) O(1)
*
* 哈希表失去了数据的顺序性，顺序性即为：
* 1、数据集中的最大值和最小值。
* 2、某个元素的前驱和后继。
* 3、某个元素的 floor 和 ceil。
* 4、某个元素的排位 rank。
* 5、选择某个排位的元素 select。
* C++ 中 map 和 set 的底层实现为平衡二叉树，unordered_map 和 unordered_set 的底层实现为哈希表。
*
* O(nlogn)
* O(n)
*/
public class Solution349 {
public int[] intersection(int[] nums1, int[] nums2) {
TreeSet<Integer> record = new TreeSet<>();
for(Integer item:nums1) {
record.add(item);
}
TreeSet<Integer> resultSet = new TreeSet<>();
for (Integer item:nums2) {
if (record.contains(item)) {
resultSet.add(item);
}
}
int[] res = new int[resultSet.size()];
int i = 0;
for(Integer item:resultSet) {
res[i++] = item;
}
return res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution454.java | data_struct_study/src/hash_table_problem/Solution454.java | package hash_table_problem;
import java.util.HashMap;
/**
* 454：
* 1、暴力解法：O(n^4)
* 2、将 D 中的元素放入查找表：O(n^3)
* 3、将 C + D 的每一种可能放入查找表中：O(n^2)
*
* O(n^2)
* O(n^2)
*/
public class Solution454 {
public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
if (A == null || B == null || C == null || D == null) {
throw new IllegalArgumentException("array is null!");
}
HashMap<Integer, Integer> record = new HashMap<>();
for (int i = 0; i < C.length; i++) {
for (int j = 0; j < D.length; j++) {
int sum = C[i] + D[j];
if (record.containsKey(sum)) {
record.put(sum, record.get(sum) + 1);
} else {
record.put(sum, 1);
}
}
}
int res = 0;
for (int i = 0; i < A.length; i++) {
for (int j = 0; j < B.length; j++) {
if (record.containsKey(-(A[i] + B[j]))) {
res += record.get(-(A[i] + B[j]));
}
}
}
return res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution350_2.java | data_struct_study/src/hash_table_problem/Solution350_2.java | package hash_table_problem;
import java.util.ArrayList;
import java.util.HashMap;
/**
* O(len(nums1) + len(nums2))
* O(len(nums1))
*/
public class Solution350_2 {
public int[] intersect(int[] nums1, int[] nums2) {
HashMap<Integer, Integer> record = new HashMap<>();
for (Integer item:nums1) {
if (!record.containsKey(item)) {
record.put(item, 1);
} else {
record.put(item, record.get(item) + 1);
}
}
ArrayList<Integer> result = new ArrayList<>();
for (Integer item:nums2) {
if (record.containsKey(item) && record.get(item) > 0) {
result.add(item);
record.put(item, record.get(item) - 1);
}
}
int[] res = new int[result.size()];
int i = 0;
for (Integer item:result) {
res[i++] = item;
}
return res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution209.java | data_struct_study/src/hash_table_problem/Solution209.java | package hash_table_problem;
/**
* 209：
* 1、字符集？
* 2、空串符合任意模式？还是不符合任意模式？
*/
public class Solution209 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution15.java | data_struct_study/src/hash_table_problem/Solution15.java | package hash_table_problem;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 题目描述：给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，
* 使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
*
* 注意：答案中不可以包含重复的三元组。
* 1、不同的三元组？
* 2、如果有多个解，解的顺序？
* 3、如果没有解。
*
* 三数之和：需要尤其注意去重，有些繁琐。
*/
public class Solution15 {
// 排序 + 双指针：时间复杂度O(n ^ 2)，空间复杂度O(n)
public List<List<Integer>> threeSum(int[] nums) {
// 1、创建一个返回链表 & 排序nums数组
List<List<Integer>> list = new ArrayList<>();
Arrays.sort(nums);
// 2、遍历数组
for (int i = 0; i < nums.length; i++) {
// 1）、初始化左右指针l、r
int l = i + 1, r = nums.length - 1;
// 2）、异常处理：第一个数组大于0，后面的数肯定比它大，肯定不成立了
if (nums[i] > 0) {
break;
}
// 3、去重1：如果不是第一个数，需要判断和上次枚举的数不同
if (i > 0 && nums[i] == nums[i - 1]) {
continue;
}
// 4、创建一个用于计算三数之和的变量sum, 当左右指针没相遇时才进行处理
int sum = -1;
while (l < r){
// 1）、计算sum
// [0, 1, 9]
sum = nums[i] + nums[l] + nums[r];
// 2）、如果sum大于0，则减小右指针，小于0则增加左指针
if(sum > 0) {
r--;
} else if (sum < 0) {
l++;
} else {
// 3）、当sum等于0时，将当前三元组添加到返回链表，
// 去重2：当左指针小于右指针时，左右指针需要判断和下次枚举的数不同，
// 最后再更新左右指针
list.add(Arrays.asList(nums[i], nums[l], nums[r]));
while (l < r && nums[l] == nums[l + 1]) {
l++;
}
while (l < r && nums[r] == nums[r - 1]) {
r--;
}
l++;
r--;
}
}
}
return list;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution219.java | data_struct_study/src/hash_table_problem/Solution219.java | package hash_table_problem;
import java.util.HashMap;
import java.util.HashSet;
/**
* 219、217（简化版219）：
* 1、暴力枚举法：O(n^2)
* 2、滑动窗口 + 查找表：O(n) 空间 O(k)
*
* O(n)
* O(k)
*/
public class Solution219 {
public boolean containsNearbyDuplicate(int[] nums, int k) {
if (nums == null || nums.length <= 1) {
return false;
}
if (k <= 0) {
return false;
}
HashSet<Integer> record = new HashSet<>();
for (int i = 0; i < nums.length; i++) {
// 1、在滑动窗口中只要有相同元素就是 true
if (record.contains(nums[i])) {
return true;
}
record.add(nums[i]);
// 2、维护滑动窗口的大小：移除滑动窗口最左边的元素
if (record.size() == k + 1) {
record.remove(nums[i - k]);
}
}
return false;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution49.java | data_struct_study/src/hash_table_problem/Solution49.java | package hash_table_problem;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
/**
* 49：
* 1、字符集
* 2、大小写敏感
*/
public class Solution49 {
public List<List<String>> groupAnagrams(String[] strs) {
HashMap<String, List<String>> map=new HashMap<>();
for (String str:strs){
char[] c=str.toCharArray();
Arrays.sort(c);
String s=String.valueOf(c);
if(map.containsKey(s))
map.get(s).add(str);
else
map.put(s,new ArrayList(Arrays.asList(str)));
}
return new ArrayList(map.values());
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution205.java | data_struct_study/src/hash_table_problem/Solution205.java | package hash_table_problem;
/**
* 205：
* 1、字符集
* 2、空串
* 3、一个字符是否可以映射到自己
*
* 记录一个字符上次出现的位置，如果两个字符串中的字符上次出现的位置一样，那么就属于同构。
*/
public class Solution205 {
public boolean isIsomorphic(String s, String t) {
int[] preIndexOfS = new int[256];
int[] preIndexOfT = new int[256];
for (int i = 0; i < s.length(); i++) {
char cs = s.charAt(i), ct = t.charAt(i);
if (preIndexOfS[cs] != preIndexOfT[ct]) {
return false;
}
preIndexOfS[cs] = i + 1;
preIndexOfT[ct] = i + 1;
}
return true;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Main.java | data_struct_study/src/hash_table_problem/Main.java | package hash_table_problem;
/**
* 两类查找问题：
* 1、查找有无：元素 a 是否存在？set；集合。
* 2、查找对应关系（键值对应）：元素 a 出现了几次？map；字典。
* 常见操作：
* 1、insert
* 2、find
* 3、erase
* 4、change（map）
*
* JsonChao的哈希表核心题库：18题
*/
public class Main {
public static void main(String[] args) {
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution_349_2.java | data_struct_study/src/hash_table_problem/Solution_349_2.java | package hash_table_problem;
import java.util.HashSet;
/**
* O(len(nums1) + len(nums2))
* O(len(nums1))
*/
public class Solution_349_2 {
public int[] intersection(int[] nums1, int[] nums2) {
HashSet<Integer> record = new HashSet<>();
for (Integer item:nums1) {
record.add(item);
}
HashSet<Integer> result = new HashSet<>();
for (Integer item:nums2) {
if (record.contains(item)) {
result.add(item);
}
}
int[] res = new int[result.size()];
int i = 0;
for (Integer item:result) {
res[i++] = item;
}
return res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution451.java | data_struct_study/src/hash_table_problem/Solution451.java | package hash_table_problem;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class Solution451 {
public String frequencySort(String s) {
// 1、创建 HashMap 字符：频率
HashMap<Character, Integer> freqCharMap = new HashMap<>();
for (Character c:s.toCharArray()) {
freqCharMap.put(c, freqCharMap.getOrDefault(c, 0) + 1);
}
// 2、创建桶 ArrayList[] 频率：字符列表
List<Character>[] freqCharList = new ArrayList[s.length() + 1];
for (char c:freqCharMap.keySet()) {
int f = freqCharMap.get(c);
if (freqCharList[f] == null) {
freqCharList[f] = new ArrayList<>();
}
freqCharList[f].add(c);
}
// 3、拼装按频率高-低的字符串
StringBuilder sb = new StringBuilder();
for (int i = freqCharList.length - 1; i >= 0; i--) {
if (freqCharList[i] != null) {
for (char c:freqCharList[i]) {
for (int j = 0; j < i; j++) {
sb.append(c);
}
}
}
}
return sb.toString();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution16.java | data_struct_study/src/hash_table_problem/Solution16.java | package hash_table_problem;
/**
* 18、16：
* 1、如果有多个解，其和 target 值的接近程度一样怎么办？
* 2、如果没解？（可不可能没解？）
*/
public class Solution16 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution1_2.java | data_struct_study/src/hash_table_problem/Solution1_2.java | package hash_table_problem;
import java.util.Arrays;
import java.util.HashMap;
/**
* O(n)
* O(n)
*/
public class Solution1_2 {
// 数组无序时：查找表(map)，将所有元素放入查找表，之后对每一个元素 a，
// 查找 target - a 是否存在, 时间复杂度O(n)
public int[] twoSum(int[] arr, int target) {
// 1、边界异常处理
int n = arr.length;
if (n < 2) {
throw new IllegalArgumentException("len of arr is illegal");
}
// 2、使用map记录每一个元素对应的值与下标
HashMap<Integer, Integer> record = new HashMap<>();
for (int i = 0; i < n; i++) {
record.put(arr[i], i);
}
// 3、遍历数组：当map中包含target-nums[i]这个key &
// 当前这个key的值不是当前元素的下标时说明已找到
for (int i = 0; i < n; i++) {
int j = target - arr[i];
if (record.containsKey(j) && record.get(j) != i) {
int[] res = {i, record.get(j)};
return res;
}
}
throw new IllegalArgumentException("no target!");
}
public static void main(String[] args) {
int[] arr = {2, 7 , 11, 15};
System.out.println(Arrays.toString(new Solution1_2().twoSum(arr, 9)));
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution350.java | data_struct_study/src/hash_table_problem/Solution350.java | package hash_table_problem;
import java.util.ArrayList;
import java.util.TreeMap;
/**
* 349（set）、350（map）：
* 1、C++ 中 map find 不到元素时输出 0
*
* O(nlogn)
* O(n)
*/
public class Solution350 {
public int[] intersect(int[] nums1, int[] nums2) {
TreeMap<Integer, Integer> record = new TreeMap<>();
for(Integer item:nums1) {
if (!record.containsKey(item)) {
record.put(item, 1);
} else {
record.put(item, record.get(item) + 1);
}
}
ArrayList<Integer> result = new ArrayList<>();
for(Integer item:nums2) {
if (record.containsKey(item) && record.get(item) > 0) {
result.add(item);
record.put(item, record.get(item) - 1);
}
}
int[] res = new int[result.size()];
int i = 0;
for(Integer item:result) {
res[i++] = item;
}
return res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution149.java | data_struct_study/src/hash_table_problem/Solution149.java | package hash_table_problem;
/**
* 149：
* 1、点坐标的范围
* 2、点坐标的表示（整数？浮点数？浮点误差？）
*/
public class Solution149 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution447.java | data_struct_study/src/hash_table_problem/Solution447.java | package hash_table_problem;
import java.util.HashMap;
/**
* 447：
* 1、枚举法（暴力法）：O(n^3)
* 2、查找表，求距离的平方，避免浮点型运算（注意避免整形移除，当然，这个题不需要处理）：O(n^2)，空间 O(n)
*
* O(n^2)
* O(n)
*/
public class Solution447 {
public int numberOfBoomerangs(int[][] points) {
int res = 0;
for (int i = 0; i < points.length; i++) {
// 1、hashMap 存储 dis:频次
HashMap<Integer, Integer> record = new HashMap<>();
for (int j = 0; j < points.length; j++) {
// 2、计算距离时不开根号，避免整形溢出
Integer dis = dis(points[i], points[j]);
if (record.containsKey(dis)) {
record.put(dis, record.get(dis) + 1);
} else {
record.put(dis, 1);
}
}
// 3、？
for (Integer dis:record.keySet()) {
res += record.get(dis) * (record.get(dis) - 1);
}
}
return res;
}
private Integer dis(int[] point1, int[] point2) {
return (point1[0] - point2[0]) * (point1[0] - point2[0]) +
(point1[1] - point2[1]) * (point1[1] - point2[1]);
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table_problem/Solution454_2.java | data_struct_study/src/hash_table_problem/Solution454_2.java | package hash_table_problem;
import java.util.HashMap;
/**
* O(n^2)
* O(n^2)
*/
public class Solution454_2 {
public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
if (A == null || B == null || C == null || D == null) {
throw new IllegalArgumentException("illegal argument!");
}
HashMap<Integer, Integer> mapAB = new HashMap<>();
for (int i = 0; i < A.length; i++) {
for (int j = 0; j < B.length; j++) {
int sum = A[i] + B[j];
if (mapAB.containsKey(sum)) {
mapAB.put(sum, mapAB.get(sum) + 1);
} else {
mapAB.put(sum, 1);
}
}
}
HashMap<Integer, Integer> mapCD = new HashMap<>();
for (int i = 0; i < C.length; i++) {
for (int j = 0; j < D.length; j++) {
int sum = C[i] + D[j];
if (mapCD.containsKey(sum)) {
mapCD.put(sum, mapCD.get(sum) + 1);
} else {
mapCD.put(sum, 1);
}
}
}
int res = 0;
for (Integer sumAB:mapAB.keySet()) {
if (mapCD.containsKey(-sumAB)) {
res += mapAB.get(sumAB) * mapCD.get(-sumAB);
}
}
return res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/segment_tree/NumArray2.java | data_struct_study/src/segment_tree/NumArray2.java | package segment_tree;
class NumArray2 {
private int[] sum;
public NumArray2(int[] nums) {
// sum[i + 1] 为 sum[0] - sum[i] 的和
// sum[0] = 0
sum = new int[nums.length + 1];
sum[0] = 0;
for (int i = 1; i < sum.length; i++) {
sum[i] = sum[i - 1] + nums[i - 1];
}
}
public int sumRange(int i, int j) {
return sum[j + 1] - sum[i];
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* int param_1 = obj.sumRange(i,j);
*/
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/segment_tree/NumArray3.java | data_struct_study/src/segment_tree/NumArray3.java | package segment_tree;
class NumArray3 {
private final int[] data;
private final int[] sum;
public NumArray3(int[] nums) {
data = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
data[i] = nums[i];
}
sum = new int[nums.length + 1];
sum[0] = 0;
for (int i = 1; i < sum.length; i++) {
sum[i] = sum[i - 1] + nums[i - 1];
}
}
public void update(int index, int val) {
data[index] = val;
for (int i = index + 1; i < sum.length; i++) {
sum[i] = sum[i - 1] + data[i - 1];
}
}
public int sumRange(int i, int j) {
return sum[j + 1] - sum[i];
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* obj.update(i,val);
* int param_2 = obj.sumRange(i,j);
*/ | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/segment_tree/Merger.java | data_struct_study/src/segment_tree/Merger.java | package segment_tree;
public interface Merger<E> {
E merge(E a, E b);
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/segment_tree/SegmentTree.java | data_struct_study/src/segment_tree/SegmentTree.java | package segment_tree;
/**
* 为什么要使用 线段树？
* 1、区间染色：m 次操作后，我们可以在区间 [i,j] 内看见多少种颜色？
* 使用数组实现 线段树
* 染色操作（更新操作） O（n) O（logn）
* 查询操作（查询区间） O（n) O（logn）
*
* 2、区间查询：查询一个区间的 最大值、最小值、后者区间数字和。
* 更新：更新区间中一个元素或者一个区间的值。
* 实质：基于区间的统计查询。
*
* segment_tree.png
*
* 线段树不是完全二叉树，但是线段树和堆都是平衡二叉树。
* 我们可以把线段树看作是一个满二叉树，对于最后一层不存在的节点，
* 看作是 null 即可，所以我们可以使用数组来表示满二叉树。
*
* 对于满二叉树：
* 1）、h 层，一共有 2^h - 1 个节点（大约是 2^h）
* 2）、最后一层（h - 1层），有 2^(h - 1) 个节点。
* 3）、最后一层的节点数大致等于前面所有层节点之和。
*
* 如果区间有 n 个元素，数组表示需要有多少节点？
* 区间固定时，需要 4n 的空间。
*
* 线段树的区间查询、指定 index 位置的值更新
*
* 线段树的区间更新：使用指定 index 位置的值更新套路需要更新叶子节点的值，时间复杂度从 O（logn）提升到 O（n），
* 可以使用 懒惰更新：使用 Lazy 数组记录未更新的内容。
*
* 上述都是一维线段树，二维线段树中每一个节点都有4个孩子节点，三维线段树中每一个节点都有8个孩子节点。
*
* 使用链表实现的动态线段树，可以避免数组实现的线段树中要多存储 null 节点的问题。
*
* 区间操作相关的另一个重要的数据结构：树状数组（Binary Index Tree）。
*
* 区间相关的问题被归类为 RMQ（Range Minimum Query）问题。
*
*/
public class SegmentTree<E> {
private Merger<E> merger;
private E[] data;
private E[] tree;
public SegmentTree(E[] arr, Merger<E> merger) {
this.merger = merger;
data = (E[])new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
tree = (E[])new Object[4 * arr.length];
buildSegmentTree(0, 0, arr.length - 1);
}
/**
* 在 treeIndex 的位置创建表示区间 [l...r] 的线段树
*
* @param treeIndex treeIndex 位置
* @param l left index
* @param r right index
*/
private void buildSegmentTree(int treeIndex, int l, int r) {
if (l == r) {
tree[treeIndex] = data[l];
return;
}
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
int mid = l + (r - l) / 2;
buildSegmentTree(leftTreeIndex, l, mid);
buildSegmentTree(rightTreeIndex, mid + 1, r);
tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}
/**
* 返回搜索区间 [queryL...queryR] 的值
*
* @param queryL queryLeft
* @param queryR queryRight
* @return 搜索区间 [queryL...queryR] 的值
*/
public E query(int queryL, int queryR) {
if ((queryL < 0 || queryL >= data.length) ||
(queryR < 0 || queryR >= data.length) ||
queryL > queryR) {
throw new IllegalArgumentException("index is illegal~");
}
return query(0, 0, data.length - 1, queryL, queryR);
}
/**
* 在以 treeIndex 为根节点、区间为 [l...r] 的线段树中，返回搜索区间 [queryL...queryR] 的值
*
* @param treeIndex 当前线段树的根节点
* @param l left
* @param r right
* @param queryL queryLeft
* @param queryR queryRight
* @return 搜索区间 [queryL...queryR] 的值
*/
private E query(int treeIndex, int l, int r, int queryL, int queryR) {
// 1、搜索区间完全等同于当前线段树的区间
if (l == queryL && r == queryR) {
return tree[treeIndex];
}
// 2、搜索区间仅存在当前线段树区间的左区间或右区间
int mid = l + (r - l) / 2;
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
if (queryL >= mid + 1) {
return query(rightTreeIndex, mid + 1, r, queryL, queryR);
} else if (queryR <= mid) {
return query(leftTreeIndex, l, mid, queryL, queryR);
}
// 3、搜索区间在当前线段树的区间的左右区间均存在
E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
return merger.merge(leftResult, rightResult);
}
/**
* 将 index 的值更新为 e
*
* @param index index
* @param e E
*/
public void set(int index, E e) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal~");
}
data[index] = e;
set(0, 0, data.length - 1, index, e);
}
/**
* 在以 treeIndex 为根的分段树中，更新 index 位置的值为 e
*
* @param treeIndex treeIndex
* @param l left
* @param r right
* @param index index
* @param e E
*/
private void set(int treeIndex, int l, int r, int index, E e) {
// 1、区间范围缩小为1时，表示找到了要更新的位置
if (l == r) {
tree[treeIndex] = e;
return;
}
// 2、通过分治思想寻找要更新的位置
int mid = l + (r - l) / 2;
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
if (index >= mid + 1) {
set(rightTreeIndex, mid + 1, r, index, e);
} else {
set(leftTreeIndex, l, mid, index, e);
}
tree[index] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}
public int getSize() {
return data.length;
}
/**
* 获取指定下标的元素
*
* @param index 下标
* @return 指定下标的元素
*/
public E get(int index) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal!");
}
return data[index];
}
/**
* 在一个由完全二叉树表示的数组中，获取当前节点的左孩子的下标
*
* @param index 当前节点的下标
* @return 当前节点的左孩子的下标
*/
private int leftChild(int index) {
return 2 * index + 1;
}
/**
* 在一个由完全二叉树表示的数组中，获取当前节点的右孩子的下标
*
* @param index 当前节点的下标
* @return 当前节点的右孩子的下标
*/
private int rightChild(int index) {
return 2 * index + 2;
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append('[');
for(int i = 0 ; i < tree.length ; i ++){
if(tree[i] != null)
res.append(tree[i]);
else
res.append("null");
if(i != tree.length - 1)
res.append(", ");
}
res.append(']');
return res.toString();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/segment_tree/Main.java | data_struct_study/src/segment_tree/Main.java | package segment_tree;
public class Main {
public static void main(String[] args) {
Integer[] nums = {-2, 0, 3, -5, 2, -1};
SegmentTree<Integer> tree = new SegmentTree<>(nums, Integer::sum);
System.out.println(tree);
System.out.println(tree.query(0, 2));
System.out.println(tree.query(2, 5));
System.out.println(tree.query(0, 5));
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/segment_tree/NumArray.java | data_struct_study/src/segment_tree/NumArray.java | package segment_tree;
class NumArray {
public interface Merger<E> {
E merge(E a, E b);
}
public class SegmentTree<E> {
private Merger<E> merger;
private E[] data;
private E[] tree;
public SegmentTree(E[] arr, Merger<E> merger) {
this.merger = merger;
data = (E[])new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
tree = (E[])new Object[4 * arr.length];
buildSegmentTree(0, 0, arr.length - 1);
}
/**
* 在 treeIndex 的位置创建表示区间 [l...r] 的线段树
*
* @param treeIndex treeIndex 位置
* @param l left index
* @param r right index
*/
private void buildSegmentTree(int treeIndex, int l, int r) {
if (l == r) {
tree[treeIndex] = data[l];
return;
}
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
int mid = l + (r - l) / 2;
buildSegmentTree(leftTreeIndex, l, mid);
buildSegmentTree(rightTreeIndex, mid + 1, r);
tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}
/**
* 返回搜索区间 [queryL...queryR] 的值
*
* @param queryL queryLeft
* @param queryR queryRight
* @return 搜索区间 [queryL...queryR] 的值
*/
public E query(int queryL, int queryR) {
if ((queryL < 0 || queryL >= data.length) ||
(queryR < 0 || queryR >= data.length) ||
queryL > queryR) {
throw new IllegalArgumentException("index is illegal~");
}
return query(0, 0, data.length - 1, queryL, queryR);
}
/**
* 在以 treeIndex 为根节点、区间为 [l...r] 的线段树中，返回搜索区间 [queryL...queryR] 的值
*
* @param treeIndex 当前线段树的根节点
* @param l left
* @param r right
* @param queryL queryLeft
* @param queryR queryRight
* @return 搜索区间 [queryL...queryR] 的值
*/
private E query(int treeIndex, int l, int r, int queryL, int queryR) {
// 1、搜索区间完全等同于当前线段树的区间
if (l == queryL && r == queryR) {
return tree[treeIndex];
}
// 2、搜索区间仅存在当前线段树区间的左区间或右区间
int mid = l + (r - l) / 2;
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
if (queryL >= mid + 1) {
return query(rightTreeIndex, mid + 1, r, queryL, queryR);
} else if (queryR <= mid) {
return query(leftTreeIndex, l, mid, queryL, queryR);
}
// 3、搜索区间在当前线段树的区间的左右区间均存在
E leftResult = query(leftTreeIndex, l, mid, queryL, mid);
E rightResult = query(rightTreeIndex, mid + 1, r, mid + 1, queryR);
return merger.merge(leftResult, rightResult);
}
/**
* 将 index 的值更新为 e
*
* @param index index
* @param e E
*/
public void set(int index, E e) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal~");
}
data[index] = e;
set(0, 0, data.length - 1, index, e);
}
/**
* 在以 treeIndex 为根的分段树中，更新 index 位置的值为 e
*
* @param treeIndex treeIndex
* @param l left
* @param r right
* @param index index
* @param e E
*/
private void set(int treeIndex, int l, int r, int index, E e) {
// 1、区间范围缩小为1时，表示找到了要更新的位置
if (l == r) {
tree[treeIndex] = e;
return;
}
// 2、通过分治思想寻找要更新的位置
int mid = l + (r - l) / 2;
int leftTreeIndex = leftChild(treeIndex);
int rightTreeIndex = rightChild(treeIndex);
if (index >= mid + 1) {
set(rightTreeIndex, mid + 1, r, index, e);
} else {
set(leftTreeIndex, l, mid, index, e);
}
tree[treeIndex] = merger.merge(tree[leftTreeIndex], tree[rightTreeIndex]);
}
public int getSize() {
return data.length;
}
/**
* 获取指定下标的元素
*
* @param index 下标
* @return 指定下标的元素
*/
public E get(int index) {
if (index < 0 || index >= data.length) {
throw new IllegalArgumentException("index is illegal!");
}
return data[index];
}
/**
* 在一个由完全二叉树表示的数组中，获取当前节点的左孩子的下标
*
* @param index 当前节点的下标
* @return 当前节点的左孩子的下标
*/
private int leftChild(int index) {
return 2 * index + 1;
}
/**
* 在一个由完全二叉树表示的数组中，获取当前节点的右孩子的下标
*
* @param index 当前节点的下标
* @return 当前节点的右孩子的下标
*/
private int rightChild(int index) {
return 2 * index + 2;
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append('[');
for(int i = 0 ; i < tree.length ; i ++){
if(tree[i] != null)
res.append(tree[i]);
else
res.append("null");
if(i != tree.length - 1)
res.append(", ");
}
res.append(']');
return res.toString();
}
}
SegmentTree<Integer> segmentTree;
public NumArray(int[] nums) {
if (nums.length <= 0) {
return;
}
Integer[] data = new Integer[nums.length];
for (int i = 0; i < nums.length; i++) {
data[i] = nums[i];
}
segmentTree = new SegmentTree<>(data, (a, b) -> a + b);
}
public void update(int i, int val) {
if (segmentTree == null) {
throw new IllegalArgumentException("Error");
}
segmentTree.set(i, val);
}
public int sumRange(int i, int j) {
if (segmentTree == null) {
throw new IllegalArgumentException("segmentTree is null!");
}
return segmentTree.query(i, j);
}
}
/**
* Your NumArray object will be instantiated and called as such:
* NumArray obj = new NumArray(nums);
* int param_1 = obj.sumRange(i,j);
*/
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/greedy_problem/Solution455_2.java | data_struct_study/src/greedy_problem/Solution455_2.java | package greedy_problem;
import java.util.Arrays;
/**
* 先尝试满足最不贪心的小朋友
* O(nlogn)
* O(1)
*/
public class Solution455_2 {
public int findContentChildren(int[] g, int[] s) {
// 1、排序
Arrays.sort(g);
Arrays.sort(s);
// 2、先尝试满足最不贪心的小朋友
int gi = 0;
int si = 0;
int res = 0;
while (gi < g.length && si < s.length) {
if (s[si] >= g[gi]) {
res++;
gi++;
}
si++;
}
return res;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/greedy_problem/Solution455.java | data_struct_study/src/greedy_problem/Solution455.java | package greedy_problem;
import java.util.Arrays;
/**
* 先尝试将最大的饼干分配给最贪心的小朋友
* O(nlogn)
* O(1)
*/
public class Solution455 {
public int findContentChildren(int[] g, int[] s) {
// 1、排序
Arrays.sort(g);
Arrays.sort(s);
// 2、先尝试将最大的饼干分配给最贪心的小朋友
int gi = g.length - 1;
int si = s.length - 1;
int res = 0;
while (gi >= 0 && si >= 0) {
if (s[si] >= g[gi]) {
res++;
si--;
}
gi--;
}
return res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/greedy_problem/Solution435_2.java | data_struct_study/src/greedy_problem/Solution435_2.java | package greedy_problem;
import java.util.Arrays;
import java.util.Comparator;
/**
* 设计贪心算法：按照区间的结尾排序，每次选择区间结尾最早的，且和前一个区间不重叠额的区间
* O(n)
* O(n)
*/
public class Solution435_2 {
// Definition for an interval.
public static class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
public int eraseOverlapIntervals(Interval[] intervals) {
// 1、按照区间的结尾排序
if (intervals.length == 0) {
return 0;
}
Arrays.sort(intervals, new Comparator<Interval>() {
@Override
public int compare(Interval o1, Interval o2) {
if (o1.end != o2.end) {
return o1.end - o2.end;
}
return o1.start - o2.start;
}
});
// 2、贪心算法：每次选择区间结尾最早的，且和前一个区间不重叠的区间
int res = 1;
int pre = 0;
for (int i = 1; i < intervals.length; i++) {
if (intervals[i].start >= intervals[pre].end) {
res++;
pre = i;
}
}
return intervals.length - res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/greedy_problem/Solution435.java | data_struct_study/src/greedy_problem/Solution435.java | package greedy_problem;
import java.util.Arrays;
import java.util.Comparator;
/**
* 贪心算法与动态规划的关系 435：
* 1、最多保留多少个区间。
* 2、暴力解法：找出所有子区间的组合，之后判断它不重叠。O((2^n)*n)
* 3、排序后，动态规划——最常上升子序列模型。
* 4、注意：每次选择中，每个区间的结尾很重要，结尾越小，留给后面的空间越大，所以后面能容纳更多区间。
* ——设计出贪心算法：按照区间的结尾排序，每次选择结尾最早的，且和前一个区间不重叠的区间。
* 5、贪心选择性质的证明：1）、举出反例。2）、反证法：贪心算法为A，最优算法为O，发现A完全能替代O，
* 且不影响求出最优解。
* 0(n ^ 2)
* O(n)
*/
public class Solution435 {
// Definition for an interval.
public static class Interval {
int start;
int end;
Interval() { start = 0; end = 0; }
Interval(int s, int e) { start = s; end = e; }
}
public int eraseOverlapIntervals(Interval[] intervals) {
if (intervals.length == 0) {
return 0;
}
// 1、排序
Arrays.sort(intervals, new Comparator<Interval>() {
@Override
public int compare(Interval o1, Interval o2) {
if (o1.start != o2.start) {
return o1.start - o2.start;
}
return o1.end - o2.end;
}
});
// 2、使用 memo[i] 统计以 intervals[i] 为结尾的区间数组的最长不重叠子序列的长度
int[] memo = new int[intervals.length];
Arrays.fill(memo, 1);
for (int i = 1; i < intervals.length; i++) {
for (int j = 0; j < i; j++) {
if (intervals[i].start >= intervals[j].end) {
memo[i] = Math.max(memo[i], 1 + memo[j]);
}
}
}
// 3、得到 memo[0...i] 范围中最大的最长不重叠子序列的长度
int res = 1;
for (int i = 0; i < intervals.length; i++) {
res = Math.max(res, memo[i]);
}
return intervals.length - res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/greedy_problem/Solution392.java | data_struct_study/src/greedy_problem/Solution392.java | package greedy_problem;
public class Solution392 {
public boolean isSubsequence(String s, String t) {
int index = -1;
for (char c:s.toCharArray()) {
index = t.indexOf(c, index + 1);
if (index == -1) {
return false;
}
}
return true;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/greedy_problem/Main.java | data_struct_study/src/greedy_problem/Main.java | package greedy_problem;
/**
* 贪心算法: 它也存在最小生成树与最短路径中。
*
* JsonChao的贪心算法题库：3题
*/
public class Main {
public static void main(String[] args) {
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack/ArrayStack.java | data_struct_study/src/stack/ArrayStack.java | package stack;
import array.Array;
/**
* 栈的一种实现方式：使用动态数组实现栈
*
* @param <E> 栈中的元素
*/
public class ArrayStack<E> implements Stack<E> {
private Array<E> array;
public ArrayStack(int capacity) {
array = new Array<>(capacity);
}
public ArrayStack() {
array = new Array<>();
}
@Override
public void push(E e) {
array.addLast(e);
}
@Override
public E pop() {
return array.deleteLast();
}
@Override
public E peek() {
return array.queryLast();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("Stack: ");
builder.append("[");
for (int i = 0; i < array.getSize(); i++) {
builder.append(array.query(i));
if (i != array.getSize() - 1) {
builder.append(",");
}
}
builder.append("] Top");
return builder.toString();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack/Stack.java | data_struct_study/src/stack/Stack.java | package stack;
/**
* Stack 的抽象接口化
* @param <E>
*/
public interface Stack<E> {
/**
* 入栈
*
* @param e 入栈的元素
*/
void push(E e);
/**
* 出栈
*
* @return e 出栈的元素
*/
E pop();
/**
* 查看栈顶的元素
*
* @return e 栈顶的元素
*/
E peek();
/**
* 获取栈元素的大小
*
* @return int 栈元素的大小
*/
int getSize();
/**
* 当前栈是否为空
*
* @return boolean 栈是否为空
*/
boolean isEmpty();
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack/Main.java | data_struct_study/src/stack/Main.java | package stack;
/**
* 栈的应用：
* 1）、无处不在的撤销操作
* 2）、系统栈的调用（操作系统）
* 3）、括号匹配（编译器）
*/
public class Main {
public static void main(String[] args) {
ArrayStack<Object> stack = new ArrayStack<>();
for (int i = 0; i < 5; i++) {
stack.push(i);
System.out.println(stack);
}
stack.pop();
System.out.println(stack);
stack.peek();
System.out.println(stack);
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack/Paththesees.java | data_struct_study/src/stack/Paththesees.java | package stack;
class Paththesees {
public boolean isValid(String s) {
// 1、注意 stack 中存的是字符： Character
Stack<Character> stack = new ArrayStack<>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
// 2、在 Java 中字符以 '' 标记，如果当前字符是左括号则放入栈中
if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else {
// 3、如果是当前字符是右括号而栈中没有左括号则匹配失败
if (stack.isEmpty()) {
return false;
}
// 4、依次判断三种括号匹配的情况即可
Character topChar = stack.pop();
if (c == ')' && topChar != '(') {
return false;
} else if (c == ']' && topChar != '[') {
return false;
} else if (c == '}' && topChar != '{') {
return false;
}
}
}
// 5、栈中没有元素才算匹配成功
return stack.isEmpty();
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table/Solution1.java | data_struct_study/src/hash_table/Solution1.java | package hash_table;
/**
* https://leetcode-cn.com/problems/first-unique-character-in-a-string/
*/
class Solution1 {
public int firstUniqChar(String s) {
int[] hashTable = new int[26];
for (int i = 0; i < s.length(); i++) {
hashTable[s.charAt(i) - 'a']++;
}
for (int i = 0; i < s.length(); i++) {
if (hashTable[s.charAt(i) - 'a'] == 1) {
return i;
}
}
return -1;
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table/HashTable.java | data_struct_study/src/hash_table/HashTable.java | package hash_table;
import java.util.TreeMap;
public class HashTable<K, V> {
private final int[] capacity
= {53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
12582917, 25165843, 50331653, 100663319, 201326611, 402653189, 805306457, 1610612741};
public static final int UPPER_TOL = 10;
public static final int LOWER_TOL = 2;
public int capacity_index;
private TreeMap<K, V>[] hashTable;
private int size;
private int M;
public HashTable() {
this.M = capacity[capacity_index];
hashTable = new TreeMap[M];
for (int i = 0; i < M; i++) {
hashTable[i] = new TreeMap<>();
}
}
private int hash(K k) {
return (k.hashCode() & 0x7fffffff) % M;
}
public int getSize() {
return size;
}
public boolean contains(K k) {
return hashTable[hash(k)].containsKey(k);
}
public void add(K k, V v) {
TreeMap<K, V> treeMap = hashTable[hash(k)];
if (treeMap.containsKey(k)) {
treeMap.put(k, v);
} else {
treeMap.put(k, v);
size++;
if (size > UPPER_TOL * M && capacity_index < capacity.length - 1) {
capacity_index++;
resize(capacity_index);
}
}
}
public V remove(K k) {
TreeMap<K, V> treeMap = hashTable[hash(k)];
V ret = null;
if (treeMap.containsKey(k)) {
ret = treeMap.remove(k);
size--;
if (size < LOWER_TOL * M && capacity_index - 1 >= 0) {
capacity_index--;
resize(capacity_index);
}
}
return ret;
}
public V set(K k, V v) {
TreeMap<K, V> treeMap = hashTable[hash(k)];
if (!treeMap.containsKey(k)) {
throw new IllegalArgumentException(k + "doesn't exist~");
}
return treeMap.put(k, v);
}
public V get(K k) {
return hashTable[hash(k)].get(k);
}
private void resize(int newCapacity) {
TreeMap[] newHashTable = new TreeMap[newCapacity];
for (int i = 0; i < newCapacity; i++) {
newHashTable[i] = new TreeMap();
}
int oldM = M;
M = newCapacity;
for (int i = 0; i < oldM; i++) {
TreeMap<K, V> treeMap = hashTable[i];
for (K k : treeMap.keySet()) {
newHashTable[hash(k)].put(k, treeMap.get(k));
}
}
hashTable = newHashTable;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table/Student.java | data_struct_study/src/hash_table/Student.java | package hash_table;
public class Student {
int grade;
int cls;
String firstName;
String lastName;
Student(int grade, int cls, String firstName, String lastName){
this.grade = grade;
this.cls = cls;
this.firstName = firstName;
this.lastName = lastName;
}
@Override
public int hashCode(){
int hash = 0;
int B = 32;
hash = hash * B + ((Integer) grade).hashCode();
hash = hash * B + ((Integer) cls).hashCode();
hash = hash * B + firstName.toUpperCase().hashCode();
hash = hash * B + lastName.toUpperCase().hashCode();
return hash;
}
@Override
public boolean equals(Object o){
if (this == o) {
return true;
}
if (o == null) {
return false;
}
if (getClass() != o.getClass()) {
return false;
}
Student student = (Student) o;
return this.grade == student.grade &&
this.cls == student.cls &&
this.firstName.toUpperCase().equals(student.firstName.toUpperCase()) &&
this.lastName.toUpperCase().equals(student.lastName.toUpperCase());
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/hash_table/Main.java | data_struct_study/src/hash_table/Main.java | package hash_table;
import avl.AVLTree;
import avl.BST;
import avl.FileOperation;
import red_black_tree.RBTree;
import java.util.ArrayList;
/**
* 什么是哈希函数？
*
* 哈希函数：将 "键" 转换为 "索引"，每一个 "键" 对应唯一的一个索引。
*
* 很难保证每一个 "键" 通过哈希函数的转换对应不同的 "索引"，因此会产生哈希冲突。
* "键" 通过哈希函数得到的 "索引" 分布越均匀越好。
*
* 在哈希表（空间换时间）上操作，主要要考虑如何解决哈希冲突。
*
* 哈希函数的设计
*
* 通用的方法——转换为整形处理：
* 1、小范围正整数直接使用。
* 2、小范围负整数进行偏移。（-100~100 => 0~200）
* 3、大整数：通常做法——取模，例如对身份证号取模后6位，即取最后6位，
* 因为倒数第5、6位是表示1~31，所以会导致分布不均匀的情况。
* 一个简单的解决办法就是模一个素数，例如7.
* 素数取值表：http://planetmath.org/goodhashtableprimes
* 4、浮点型：在计算机中都是32位或64位的二进制表示，只不过计算机解析成了浮点数。
* 我们可以直接将二进制转换为整形来处理。
* 5、字符串：
* 166 = 1 * 10^2 + 6 * 10^1 + 6 * 10^0
* code = c * 26^3 + o * 26^2 + d * 26^1 + e * 26^0
* code = c * B^3 + o * B^2 + d * B^1 + e * B^0
* hash(code) = (c * B^3 + o * B^2 + d * B^1 + e * B^0) % M(素数）
* 降低计算量：
* hash(code) = ((((c * B) + o) * B + d) * B) + e) % M
* 避免整形溢出：
* hash(code) = ((((c % M） * B + o) % M * B + d) % M * B + e) % M
* 代码形式：
* int hash = 0;
* for(int i = 0;i < s.length();i++) {
* hash = (hash * B + s.charAt(i)) % M;
* }
* 6、复合类型：也是利用字符串的上述公式，例如 Date：year、month、day。
* hash(code) = (((date.year % M) * B + date.month) % M * B + date.day) % M
* 设计原则：
* 1、一致性：如果 a == b，则 hash(a) == hash(b)
* 2、高效性：计算高效简便
* 3、均匀性：哈希值均匀分布
*
* Java 中 Object 的 hashCode 是根据每一个对象的地址映射成整形。
*
* 哈希冲突的处理
* 1、链地址法（Separate Chaining）：
* 去掉 k1 符号：（hashCode(k1) & 0x7fffffff) % M，& 0x7fffffff 表示将 k1 最高位变为0。
* HashMap 本质就是一个 TreeMap 数组。
* HashSet 本质就是一个 TreeSet 数组。
* Java8 之前，每一个位置对应一个链表，Java8 开始，当哈希冲突达到一定程度
* （平均来讲，每一个位置存储的元素树多于某一个程度了），每一个位置从链表转成红黑树。
* HashMap 容量的选取非常重要，恰当的容量能够避免数组扩容和尽量减少 hash 冲突。
* 算法复杂度分析：
* 总共有 M 个地址，如果放入哈希表的元素为 N。
* 如果地址是链表：O(N/M)
* 如果地址是平衡树：O(log(N/M))
* 为了实现均摊复杂度 O(1)，需要对哈希表进行动态空间处理，即
* 1、平均每个地址承载的元素多过一定程度，即扩容 N/M >= upperTol
* 2、平均每个地址承载的元素少过一定程度，即缩容 N/M < lowerTol
* 3、对于哈希表来说，元素树从 N 增加到 upperTol * N，地址空间翻倍
* 4、每个操作在 O(LOWER_TOL)~O(UPPER_TOL) => O(1)
*
* 更复杂的动态空间处理方法
* 扩容 M -> 2 * M => 不是素数
* 解决方案：使用素数取值表中的值：http://planetmath.org/goodhashtableprimes
*
* 哈希表相比 AVL、红黑树 而言，牺牲了顺序性，换来了更好的性能。
* 集合、映射：
* 1、有序集合（TreeSet）、有序映射（TreeMap）：平衡树。
* 2、无序集合（HashSet）、无序映射（HashMap）：哈希表。
*
* 更多的哈希冲突处理方法：
* 1、开发地址法（线性探测法）：对于开放地址法来说，每一个地址就是直接存元素，
* 即每一个地址都对所有的元素是开放的。如果有冲突，直接存到当前索引的下一个索引对应的位置，
* 如果位置还被占用，继续往下寻找即可。
* (平方探测法)： +1、+4、+9、+16。
* (二次哈希法)：使用另外一个 hash 算法来计算出下一个位置要去哪儿，hash2(key)。
* 负载率（LoaderFactory）：元素占总容量比，超过它就需要进行扩容，
* 一般选取为50%，选取合适时间复杂度可以到达 O(1)。
* 2、再哈希法（Rehashing）：使用另外一个 hash 算法来计算出下一个位置要去哪儿。
* 3、Coalesced Hashing：综合了 Separate Chaining 和 Open Addressing。
*
*/
public class Main {
public static void main(String[] args) {
// int a = 42;
// System.out.println(((Integer)a).hashCode());
//
// int b = -42;
// System.out.println(((Integer)b).hashCode());
//
// double c = 3.1415926;
// System.out.println(((Double)c).hashCode());
//
// String d = "imooc";
// System.out.println(d.hashCode());
//
// System.out.println(Integer.MAX_VALUE + 1);
// System.out.println();
//
// Student student = new Student(3, 2, "Bobo", "Liu");
// System.out.println(student.hashCode());
//
// HashSet<Student> set = new HashSet<>();
// set.add(student);
//
// HashMap<Student, Integer> scores = new HashMap<>();
// scores.put(student, 100);
//
// Student student2 = new Student(3, 2, "Bobo", "Liu");
// System.out.println(student2.hashCode());
System.out.println("Pride and Prejudice");
ArrayList<String> words = new ArrayList<>();
if(FileOperation.readFile("pride-and-prejudice.txt", words)) {
System.out.println("Total words: " + words.size());
// Collections.sort(words);
// Test BST
long startTime = System.nanoTime();
BST<String, Integer> bst = new BST<>();
for (String word : words) {
if (bst.contains(word))
bst.set(word, bst.get(word) + 1);
else
bst.add(word, 1);
}
for(String word: words)
bst.contains(word);
long endTime = System.nanoTime();
double time = (endTime - startTime) / 1000000000.0;
System.out.println("BST: " + time + " s");
// Test AVL
startTime = System.nanoTime();
AVLTree<String, Integer> avl = new AVLTree<>();
for (String word : words) {
if (avl.contains(word))
avl.set(word, avl.get(word) + 1);
else
avl.add(word, 1);
}
for(String word: words)
avl.contains(word);
endTime = System.nanoTime();
time = (endTime - startTime) / 1000000000.0;
System.out.println("AVL: " + time + " s");
// Test RBTree
startTime = System.nanoTime();
RBTree<String, Integer> rbt = new RBTree<>();
for (String word : words) {
if (rbt.contains(word))
rbt.set(word, rbt.get(word) + 1);
else
rbt.add(word, 1);
}
for(String word: words)
rbt.contains(word);
endTime = System.nanoTime();
time = (endTime - startTime) / 1000000000.0;
System.out.println("RBTree: " + time + " s");
// Test HashTable
startTime = System.nanoTime();
// HashTable<String, Integer> ht = new HashTable<>();
HashTable<String, Integer> ht = new HashTable<>();
for (String word : words) {
if (ht.contains(word))
ht.set(word, ht.get(word) + 1);
else
ht.add(word, 1);
}
for(String word: words)
ht.contains(word);
endTime = System.nanoTime();
time = (endTime - startTime) / 1000000000.0;
System.out.println("HashTable: " + time + " s");
}
System.out.println();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/queue/LoopQueue.java | data_struct_study/src/queue/LoopQueue.java | package queue;
/**
* 循环队列：
* 采用队尾和队首两个指针：front、tail，目的是将普通队列中的 出队
* 时间复杂度降为 O（1），省去复制数组的操作。
*
*
* @param <E>
*/
public class LoopQueue<E> implements Queue<E> {
private E[] data;
private int front, tail;
private int size;
public LoopQueue(int capacity) {
data = (E[]) new Object[capacity + 1];
front = 0;
tail = 0;
size = 0;
}
public LoopQueue() {
this(10);
}
public int getCapacity() {
return data.length - 1;
}
/**
* 队列为空时，front 与 tail 都指向同一处
*
* @return 队列是否为空
*/
@Override
public boolean isEmpty() {
return front == tail;
}
@Override
public int getSize() {
return size;
}
@Override
public void enqueue(E e) {
// 队尾位置 + 1 == 堆首 时，循环对面为满，空出一个空间是为了区分开 判断队列是空还是满的情况。
if ((tail + 1) % data.length == front) {
resize(getCapacity() * 2);
}
// 正常的入队操作
data[tail] = e;
tail = (tail + 1) % data.length;
size++;
}
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity + 1];
for (int i = 0; i < size; i++) {
// 将 data 中 front ~ tail 的元素复制到 newData 中的 0 ~ size - 1 处。
newData[i] = data[(front + i) % data.length];
}
data = newData;
front = 0;
tail = size;
}
@Override
public E dequeue() {
if (isEmpty()) {
throw new IllegalArgumentException("no data!");
}
// 预先取出要返回的出队元素
E e = data[front];
// 设置出队元素为空，避免产生游离的对象
data[front] = null;
// 循环队列的好处就在于可以 利用 front 后移一位来替代 普通队列中的遍历复制操作。
front = (front + 1) % data.length;
size--;
// 缩容时注意判断要缩容的容积不能为 0
if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
resize(getCapacity() / 2);
}
return e;
}
@Override
public E getFront() {
if (isEmpty()) {
throw new IllegalArgumentException("no data!");
}
return data[front];
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(String.format("Queue size is %d\n", size));
stringBuilder.append("Front [ ");
for (int i = 0; i < size; i++) {
stringBuilder.append(data[(front + i) % data.length]);
if (i != (size - 1) % data.length) {
stringBuilder.append(",");
}
}
stringBuilder.append(" ] Tail");
return stringBuilder.toString();
}
public static void main(String[] args) {
LoopQueue<Object> queue = new LoopQueue<>();
for (int i = 0; i < 10; i++) {
queue.enqueue(i);
if (i % 3 == 2) {
queue.dequeue();
}
System.out.println(queue);
}
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/queue/ArrayQueue.java | data_struct_study/src/queue/ArrayQueue.java | package queue;
/**
* 数组队列实现：
* 其中 enqueue 的时间复杂度为 O（n)，需要使用循环队列改进为 O（1）。
*
* @param <E>
*/
public class ArrayQueue<E> implements Queue<E> {
private Array<E> array;
public ArrayQueue() {
array = new Array<>();
}
public ArrayQueue(int capacity) {
array = new Array<>(capacity);
}
@Override
public void enqueue(E e) {
array.addLast(e);
}
@Override
public E dequeue() {
return array.deleteFirst();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public E getFront() {
return array.queryFirst();
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(String.format("Queue size is %d\n", array.getSize()));
stringBuilder.append("Front [ ");
for (int i = 0; i < array.getSize(); i++) {
stringBuilder.append(array.query(i));
if (i != array.getSize() - 1) {
stringBuilder.append(",");
}
}
stringBuilder.append(" ] Tail");
return stringBuilder.toString();
}
public static void main(String[] args) {
ArrayQueue<Object> queue = new ArrayQueue<>();
for (int i = 0; i < 10; i++) {
queue.enqueue(i);
if (i % 3 == 2) {
queue.dequeue();
}
System.out.println(queue);
}
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/queue/Array.java | data_struct_study/src/queue/Array.java | package queue;
/**
* 1、实现基本功能：增删改查、各种判断方法等等
* 2、使用 泛型 让我们的数据结构可以放置 "任何"（不可以是基本
* 数据类型，只能是类对象，好在每一个基本类型都有一个对应的
* 包装类，它们之间可以自动进行装箱和拆箱的操作） 的数据类型
* 3、数组的扩容与缩容
*
* 手写时的易错点：
* 1、注意数组的下标
* 2、注意 size 与 capacity 的区别
*
* 简单的时间复杂度分析：
* 为什么要用大O，叫做大O(n)？
* 忽略了常数，实际时间 T = c1 * n + c2
* 为甚不加上其中每一个常数项，而是要忽略它？
* 比如说把一个数组中的元素取出来这个操作，很有可能不同的语音基于不同的实现，它实际运行的时间是不等的。
* 就算转换成机器码，它对应的那个机器码的指令数也有可能是不同的。就算指令数是相同的，同样一个指令在 CPU
* 的底层，你使用的 CPU 不同，很有可能执行的操作也是不同的。所以，在实际上我们大概能说出来这个 c1
* 是多少，但是很难准确判断其具体的值。
* 大O的表示的是渐进时间复杂度，当 n 趋近于无穷大的时候，其算法谁快谁慢。
* 增：O（n)
* 删：O（n）
* 改：已知索引 O（1）；未知索引 O（n）
* 查：已知索引 O（1）；未知索引 O（n）
*
* 均摊时间复杂度分析：
* 假设 capacity = n，n + 1 次 addLast/removeLast，触发 resize，总共进行 2n + 1 次基本操作
* 平均来看，每次 addLast/removeLast 操作，进行 2 次基本操作
* 均摊计算，时间复杂度为 O（1）
*
* 复杂度震荡：
* 当反复先后调用 addLast/removeLast 进行操作时，会不断地进行 扩容/缩容，此时时间复杂度为 O（n）
* 出现问题的原因：removeLast 时 resize 过于着急
* 解决方案：Lazy （在这里是 Lazy 缩容）
* 等到 size == capacity / 4 时，才将 capacity 减半
*
* Array 泛型中盛放的是 E 类型的数据
*/
public class Array<E> {
/**
* capacity 即为 data.length
*/
private E[] data;
/**
* size 即为 当前数组的大小
*/
private int size;
/**
* 构造函数：创建一个具有 capacity 容量的数组
* @param capacity 容量大小
*/
public Array(int capacity) {
// Object 这里导入了别的 Object 接口(org.omg.CORBA.Object)，
// 导致浪费了半小时查找错误。。
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 默认构造函数：数组容量大小为 10
*/
public Array() {
this(10);
}
/**
* 获取数组的容量
* @return 容量
*/
public int getCapacity() {
return data.length;
}
/**
* 获取数组的大小
*/
public int getSize() {
return size;
}
/**
* 判断数组是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 向数组最后添加一个元素
* 时间复杂度：O（1）
*/
public void addLast(E e) {
add(size, e);
}
/**
* 向数组开始添加一个元素
* 时间复杂度：O（n）
*/
public void addFirst(E e) {
add(0, e);
}
/**
* 向数组指定位置添加一个元素
* 时间复杂度：O（n）
* 数组的添加操作的总体时间复杂度为 O（n），需要考虑最坏的情况
*/
public void add(int position, E e) {
/**
* 插入的形式只有如下三种：
* 1、从开始插入元素：data[0]
* 2、从最后插入元素：data[size]
* 3、从中间插入元素：data[0~size]
*/
if ((position < 0 || position > size)) {
throw new IllegalArgumentException("add failed, position is illegal");
}
if (size == data.length) {
// 数组扩容，Java 中的扩容机制是 1.5 倍
resize(data.length * 2);
}
for (int i = size - 1; i >= position; i--) {
data[i + 1] = data[i];
}
data[position] = e;
size++;
}
/**
* 扩容/缩容
* 时间复杂度：O（n）
* @param capacity
*/
private void resize(int capacity) {
E[] newData = (E[]) new Object[capacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
}
/**
* 查询数组中最后一个位置的元素
*
* @return 数组中的元素
*/
public E queryLast() {
return query(getSize() - 1);
}
/**
* 查询数组中第一个位置的元素
*
* @return 数组中的元素
*/
public E queryFirst() {
return query(0);
}
/**
* 查询数组中指定位置的元素
*
* @return 数组中的元素
*/
public E query(int position) {
if (position < 0 || position >= size) {
throw new IllegalArgumentException("position is illegal~");
}
return data[position];
}
/**
* 修改数组中指定位置的元素
*/
public void set(int position, E e) {
if (position < 0 || position >= size) {
throw new IllegalArgumentException("position is illegal~");
}
data[position] = e;
}
/**
* 数组中是否包含某元素
*
* @return 是否包含某元素
*/
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return true;
}
}
return false;
}
/**
* 查找数组中对应元素的下标
*
* @return 对应元素的下标
*/
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
/**
* 删除数组中最开始的元素
*
* @return 被删除的元素
*/
public E deleteFirst() {
return delete(0);
}
/**
* 删除数组中最后的元素
*
* @return 被删除的元素
*/
public E deleteLast() {
return delete(size - 1);
}
/**
* 删除数组中指定的元素
*
* @param e 被删除的元素
* @return 是否删除成功
*/
public boolean deleteElement(E e) {
int index = find(e);
if (index != -1) {
delete(index);
return true;
}
return false;
}
/**
* 删除数组中指定下标的元素
*
* @return 被删除的元素
*/
public E delete(int position) {
if ((position < 0 || position >= size)) {
throw new IllegalArgumentException("position is illegal!");
}
E deleteE = data[position];
for (int i = position + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
// 节省空间
data[size] = null;
// 防止复杂度的震荡，同时注意处理 data.length / 2 = 0（即 data.length < 2) 的情况
if (size == data.length / 4 && data.length / 2 != 0) {
// 数组的缩容
resize(data.length / 2);
}
return deleteE;
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append(String.format("Array size is %d, length is %d\n", size, data.length));
stringBuilder.append("[");
for (int i = 0; i < size; i++) {
stringBuilder.append(data[i]);
if (i != size - 1) {
stringBuilder.append(",");
}
}
stringBuilder.append("]");
return stringBuilder.toString();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/queue/Main.java | data_struct_study/src/queue/Main.java | package queue;
import LinkedList.LinkedListQueue;
import java.util.Random;
public class Main {
// 测试使用q运行opCount个enqueueu和dequeue操作所需要的时间，单位：秒
private static double testQueue(Queue<Integer> q, int opCount){
long startTime = System.nanoTime();
Random random = new Random();
for(int i = 0 ; i < opCount ; i ++)
q.enqueue(random.nextInt(Integer.MAX_VALUE));
for(int i = 0 ; i < opCount ; i ++)
q.dequeue();
long endTime = System.nanoTime();
return (endTime - startTime) / 1000000000.0;
}
public static void main(String[] args) {
int opCount = 100000;
ArrayQueue<Integer> arrayQueue = new ArrayQueue<Integer>();
double time1 = testQueue(arrayQueue, opCount);
System.out.println("ArrayQueue, time: " + time1 + " s");
LoopQueue<Integer> loopQueue = new LoopQueue<>();
double time2 = testQueue(loopQueue, opCount);
System.out.println("LoopQueue, time: " + time2 + " s");
LinkedListQueue<Integer> linkedListQueue = new LinkedListQueue<Integer>();
double time3 = testQueue(linkedListQueue, opCount);
System.out.println("LinkedListQueue, time: " + time3 + " s");
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/queue/Queue.java | data_struct_study/src/queue/Queue.java | package queue;
public interface Queue<E> {
void enqueue(E e);
E dequeue();
boolean isEmpty();
int getSize();
E getFront();
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution94.java | data_struct_study/src/stack_problem/Solution94.java | package stack_problem;
import java.util.ArrayList;
import java.util.List;
/**
* O(n)：树中的节点个数。
* O(h)：树的高度。
*/
public class Solution94 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
public List<Integer> inorderTraversal(TreeNode root) {
// 1、创建一个返回列表
List<Integer> res = new ArrayList<>();
inorderTraversal(root, res);
return res;
}
// 2、递归实现中序遍历：左根右
private void inorderTraversal(TreeNode root, List<Integer> res) {
if (root != null) {
inorderTraversal(root.left, res);
res.add(root.val);
inorderTraversal(root.right, res);
}
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution_1.java | data_struct_study/src/stack_problem/Solution_1.java | package stack_problem;
import java.util.Stack;
/**
* 用两个栈来实现一个队列，完成队列的 Push 和 Pop 操作。
*
* 1、in 栈用来处理入栈操作，out 栈用来处理出栈操作。
* 一个元素进入 in 栈之后，出栈的顺序被反转。当元素要出栈时，
* 需要先进入 out 栈，此时元素出栈顺序再一次被反转，因此出栈顺序
* 就和最开始入栈顺序是相同的，先进入的元素先退出，这就是队列的顺序。
*
* 2、在in栈中写入，要输出时，将所有in栈数据移到out栈，然后只要out栈数据不为空，
* 就可以一直取出，一旦为空，则再将in栈数据移到out栈中即可。
*/
public class Solution_1 {
Stack<Integer> in = new Stack<>();
Stack<Integer> out = new Stack<>();
public void push(int node) {
in.push(node);
}
// 1、要确保每次只有当out栈为空时才从第in栈中pop值到out栈中，以防止来回倒
public int pop() throws Exception {
if (out.isEmpty()) {
while (!in.isEmpty()) {
out.push(in.pop());
}
}
if (out.isEmpty()) {
throw new Exception("queue is empty");
}
return out.pop();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution341.java | data_struct_study/src/stack_problem/Solution341.java | package stack_problem;
/**
* 341：对于 [1[4,[6]]], 在 hasNext() 为 true 的情况下，不断调用 next(), 依次获得 1 4 6。
*/
public class Solution341 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution94_2.java | data_struct_study/src/stack_problem/Solution94_2.java | package stack_problem;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* 模拟系统栈，非递归二叉树的中序遍历
* O(n)
* O(h)
*/
public class Solution94_2 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
public class Command {
String s;
TreeNode node;
public Command(String s, TreeNode node) {
this.s = s;
this.node = node;
}
}
public List<Integer> inorderTraversal(TreeNode root) {
// 1、创建一个返回列表，如果根节点为null，直接返回
ArrayList<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
// 2、创建一个Stack<Command>对象模拟系统栈实现非递归二叉树的中序遍历：倒过来看为左根右
Stack<Command> stack = new Stack<>();
stack.push(new Command("go", root));
while (!stack.isEmpty()) {
Command command = stack.pop();
if (command.s.equals("print")) {
res.add(command.node.val);
} else if (command.s.equals("go")) {
if (command.node.right != null) {
stack.push(new Command("go", command.node.right));
}
stack.push(new Command("print", command.node));
if (command.node.left != null) {
stack.push(new Command("go", command.node.left));
}
}
}
return res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution71.java | data_struct_study/src/stack_problem/Solution71.java | package stack_problem;
/**
* 71：
* 1、这个路径是否一定合法？
* 2、不能回退的情况？（如 /../, 返回 /）
* 3、多余的 /?（如 /home//hello/, 返回 /home/hello)
*/
public class Solution71 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution144.java | data_struct_study/src/stack_problem/Solution144.java | package stack_problem;
import java.util.ArrayList;
import java.util.List;
/**
* 144、94、145：
* 1、递归实现。
* 2、循环实现：使用栈模拟系统栈，写出非递归程序。
* O(n)
* O(h)
*/
public class Solution144 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public List<Integer> preorderTraversal(TreeNode root) {
// 1、创建一个返回列表
ArrayList<Integer> res = new ArrayList<>();
preorderTraversal(root, res);
return res;
}
// 2、递归实现前序遍历：根左右
private void preorderTraversal(TreeNode node, ArrayList<Integer> res) {
if (node != null) {
res.add(node.val);
preorderTraversal(node.left, res);
preorderTraversal(node.right, res);
}
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution20.java | data_struct_study/src/stack_problem/Solution20.java | package stack_problem;
import java.util.Stack;
/**
* 时间复杂度：O(n)
* 空间复杂度：O(n)
*/
public class Solution20 {
public boolean isValid(String s) {
// 1、创建一个栈，注意 stack 中存的是字符：Character
Stack<Character> stack = new Stack<>();
// 2、遍历字符串
for (int i = 0; i < s.length(); i++) {
// 1）、在 Java 中字符以 '' 标记，如果当前字符是左括号则放入栈中
char c = s.charAt(i);
if (c == '(' || c == '[' || c == '{') {
stack.push(c);
} else {
// 2）、如果当前字符是右括号而栈中没有左括号则匹配失败,
// 这里依次判断三种括号匹配的情况即可
if (stack.isEmpty()) {
return false;
}
Character topChar = stack.pop();
if (c == ')' && topChar != '(') {
return false;
} else if (c == ']' && topChar != '[') {
return false;
} else if (c == '}' && topChar != '{') {
return false;
}
}
}
// 3、栈中没有元素才算匹配成功
return stack.isEmpty();
}
public static void main(String[] args) {
System.out.println(new Solution20().isValid("(({[{}]}))"));
}
} | java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution155.java | data_struct_study/src/stack_problem/Solution155.java | package stack_problem;
import java.util.Stack;
/**
* 使用双栈（数据栈+最小值栈）+min实现最小值栈
*/
public class Solution155 {
private Stack<Integer> mDataStack;
private Stack<Integer> mMinStack;
private int min;
public Solution155() {
// 1、创建一个数据栈保存数据，最小值栈的栈顶维护最小值，min变量维护最小值
mDataStack = new Stack<>();
mMinStack = new Stack<>();
min = Integer.MAX_VALUE;
}
// 2、放入元素时保持栈顶的元素为最小值
public void push(int e) {
mDataStack.push(e);
min = Math.min(min, e);
mMinStack.push(min);
}
// 3、弹出元素时保持min记录的为最小值
public void pop() {
mDataStack.pop();
mMinStack.pop();
min = mMinStack.isEmpty() ? Integer.MAX_VALUE : mMinStack.peek();
}
// 4、查看最小值
public int getMin() {
return mMinStack.peek();
}
// 5、查看栈顶值
public int top() {
return mDataStack.peek();
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution145.java | data_struct_study/src/stack_problem/Solution145.java | package stack_problem;
import java.util.ArrayList;
import java.util.List;
/**
* O(n)
* O(h)
*/
public class Solution145 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public List<Integer> postorderTraversal(TreeNode root) {
// 1、创建一个返回列表
ArrayList<Integer> res = new ArrayList<>();
postorderTraversal(root, res);
return res;
}
// 2、递归实现二叉树的后续遍历：左右根
private void postorderTraversal(TreeNode node, ArrayList<Integer> res) {
if (node != null) {
postorderTraversal(node.left, res);
postorderTraversal(node.right, res);
res.add(node.val);
}
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution145_2.java | data_struct_study/src/stack_problem/Solution145_2.java | package stack_problem;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* O(n)
* O(h)
*/
public class Solution145_2 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
class Command {
String val;
TreeNode node;
public Command(String s, TreeNode node) {
this.val = s;
this.node = node;
}
}
public List<Integer> postOrderTraversal(TreeNode root) {
// 1、创建一个返回列表，如果根节点为null，则直接返回
List<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
// 2、使用栈Stack<Command>模拟系统栈实现二叉树的非递归遍历：倒过来看为左右根，为什么？因为栈是先进后出的
Stack<Command> stack = new Stack<>();
stack.push(new Command("go", root));
while (!stack.isEmpty()) {
Command command = stack.pop();
if (command.val.equals("print")) {
res.add(command.node.val);
} else if (command.val.equals("go")) {
stack.push(new Command("print", command.node));
if (command.node.right != null) {
stack.push(new Command("go", command.node.right));
}
if (command.node.left != null) {
stack.push(new Command("go", command.node.left));
}
}
}
return res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Main.java | data_struct_study/src/stack_problem/Main.java | package stack_problem;
/**
* 栈问题
*
* JsonChao的栈核心题库：8题
*/
public class Main {
public static void main(String[] args) {
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution144_2.java | data_struct_study/src/stack_problem/Solution144_2.java | package stack_problem;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
/**
* O(n)
* O(h)
*/
public class Solution144_2 {
// Definition for a binary tree node.
public class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) {
val = x;
}
}
public class Command {
String s;
TreeNode node;
public Command(String s, TreeNode node) {
this.s = s;
this.node = node;
}
}
public List<Integer> preorderTraversal(TreeNode root) {
// 1、创建一个返回列表，如果根节点为空，则直接返回
ArrayList<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
// 2、使用Stack<Command>对象模拟系统栈实现二叉树的非递归前序遍历：
// 倒过来看为根左右，为什么？因为栈是先进后出的
Stack<Command> stack = new Stack<>();
stack.push(new Command("go", root));
while (!stack.isEmpty()) {
Command command = stack.pop();
if (command.s.equals("print")) {
res.add(command.node.val);
} else if (command.s.equals("go")) {
if (command.node.right != null) {
stack.push(new Command("go", command.node.right));
}
if (command.node.left != null) {
stack.push(new Command("go", command.node.left));
}
// 注意栈是先进后出的，不同于递归写法，这里顺序需要反过来
stack.push(new Command("print", command.node));
}
}
return res;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution150.java | data_struct_study/src/stack_problem/Solution150.java | package stack_problem;
/**
* 150：
* 1、运算的种类（+，-，*，/）
* 2、字符串表达的数字种类（整数）
*/
public class Solution150 {
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/stack_problem/Solution_2.java | data_struct_study/src/stack_problem/Solution_2.java | package stack_problem;
import java.util.Stack;
/**
* 题目描述：请写一个整数计算器，支持加减乘三种运算和括号。
*
* (2*(3-4))*5：不断递归，先计算最里面括号的值，并保存在栈中，然后再计算外面括号的。
* 1.用栈保存各部分计算的和
* 2.遍历表达式
* 3.遇到数字时继续遍历求这个完整的数字的值
* 4.遇到左括号时递归求这个括号里面的表达式的值
* 5.遇到运算符时或者到表达式末尾时，就去计算上一个运算符并把计算结果push进栈，然后保存新的运算符
* 如果是+，不要计算，push进去
* 如果是-，push进去负的当前数
* 如果是×、÷，pop出一个运算数和当前数作计算
* 6.最后把栈中的结果求和即可
*/
public class Solution_2 {
// (2*(3-4))*5：不断递归，先计算最里面括号的值，并保存在栈中，然后再计算外面括号的
public int solve(String s) {
// 1、创建一个栈保存各部分计算的和
Stack<Integer> stack = new Stack<>();
// 2、创建sum记录当前部分的和，number记录当前数字，sign记录运算符号，默认为+号
int sum = 0, number = 0;
char sign = '+';
// 3、遍历字符数组
char[] charArray = s.toCharArray();
for (int i = 0, n = charArray.length; i < n; i++) {
// 1）、如果当前字符是左括号时使用递归去掉最外面括号，并求这个括号里面表示式的值
char c = charArray[i];
if (c == '(') {
// 1）、初始化变量j记录右括号的下一个位置与括号对变量counterPar
int j = i + 1;
int counterPar = 1;
// 2）、当括号对数大于0时，如果当前位置元素为左括号则括号对数+1，否则-1，然后移动变量j的位置
while (counterPar > 0) {
if (charArray[j] == '(') {
counterPar++;
}
if (charArray[j] == ')') {
counterPar--;
}
j++;
}
// 3）、递归计算括号里面表达式的值
number = solve(s.substring(i + 1, j - 1));
// 4）、更新当前遍历的下标i：直接定位到右括号位置j-1处
i = j - 1;
}
// 2）、如果当前字符是数字，则使用number记录当前数字
if (Character.isDigit(c)) {
number = number * 10 + c - '0';
}
// 3）、如果当前字符是运算符或者到表达式末尾时，就去计算上一个运算符，
// 并把计算结果push进栈，然后保存新的运算符
if (!Character.isDigit(c) || i == n - 1) {
// 1）、如果是+，不要计算，push进去
if (sign == '+') {
stack.push(number);
} else if (sign == '-') {
// 2）、如果是-，push进去负的当前数
stack.push(-1 * number);
} else if (sign == '*') {
// 3）、如果是×、÷，pop出一个运算数和当前数作计算
stack.push(stack.pop() * number);
} else if (sign == '/') {
stack.push(stack.pop() / number);
}
// 4）、重置number为0，sign为c
number = 0;
sign = c;
}
}
// 4、最后把栈中的结果求和即可
while (!stack.isEmpty()) {
sum += stack.pop();
}
return sum;
}
public static void main(String[] args) {
System.out.println(new Solution_2().solve("(2*(3-4))*5"));
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/LinkedList_problem/Solution148.java | data_struct_study/src/LinkedList_problem/Solution148.java | package LinkedList_problem;
/**
* 排序链表：【merge sort + Floyd】
*/
public class Solution148 {
public ListNode sortList(ListNode head){
if (head==null||head.next==null) return head;
ListNode fast = head.next;
ListNode slow = head;
while (fast!=null && fast.next!=null){
fast = fast.next.next;
slow = slow.next;
}
ListNode curr = slow.next;
slow.next = null;
head = sortList(head);
curr = sortList(curr);
ListNode pre = new ListNode(0);
slow = pre;
while (head!=null&&curr!=null){
if (head.val<curr.val){
pre.next = head; pre = pre.next; head = head.next;
}
else{
pre.next = curr; pre = pre.next; curr = curr.next;
}
}
pre.next = head==null? curr:head;
return slow.next;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
JsonChao/Awesome-Algorithm-Study | https://github.com/JsonChao/Awesome-Algorithm-Study/blob/f1c886eabf744b69e72a0b0a64b348032b439037/data_struct_study/src/LinkedList_problem/Solution_4_2.java | data_struct_study/src/LinkedList_problem/Solution_4_2.java | package LinkedList_problem;
import java.util.ArrayList;
import java.util.List;
/**
* 判断链表是否是一个回文结构
*
* 时间复杂度：O(n)
* 空间复杂度：O(n)
*/
public class Solution_4_2 {
// 2、动态数组（ArrayList) + 双指针解法
public boolean isPail(ListNode head) {
// 1、创建一个动态数组，并将链表中的节点都放入里面
List<Integer> list = new ArrayList<>();
ListNode cur = head;
while (cur != null) {
list.add(cur.val);
cur = cur.next;
}
// 2、初始化一头一尾两个双指针，并同时往中间移动进行比较
int first = 0;
int last = list.size() - 1;
while (first < last) {
if (!list.get(first).equals(list.get(last))) {
return false;
}
first++;
last--;
}
return true;
}
}
| java | Apache-2.0 | f1c886eabf744b69e72a0b0a64b348032b439037 | 2026-01-05T02:39:40.141219Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.