public boolean canJump(int[] nums) {
if(nums.length ==1) return true;
int coverRange = 0;
for(int i=0; i<=coverRange; i++){ // 遍历coverRange，因为coverRange是当前可以跳跃的最大距离，所以遍历coverRange即可
coverRange = Math.max(coverRange, i+nums[i]); // 站在第i个位置，最多可以跳nums[i]步
if(coverRange >= nums.length-1) return true; // 如果coverRange >= nums.length-1（最后一个索引位置），则可以到达最后一个位置
}
return false;
}A 长度 = 3 (a1 → a2 → c1 → c2 → c3)
B 长度 = 4 (b1 → b2 → b3 → c1 → c2 → c3)
pA: a1 → a2 → c1 → c2 → c3 → null → b1 → b2 → b3 → c1 ←★
pB: b1 → b2 → b3 → c1 → c2 → c3 → null → a1 → a2 → c1 ←★
最后pA和pB都走了9步，在c1相遇, 因为c1是相交点public boolean isPalindrome(String s) {
if (" ".equals(s)) return true; // 如果字符串为空，则返回true
int left = 0, right = s.length()-1;
while(left <= right){
while (left < right && !Character.isLetterOrDigit(s.charAt(left))) { // 如果左指针指向的字符不是字母或数字，则移动左指针
left++;
}
while (left < right && !Character.isLetterOrDigit(s.charAt(right))) { // 如果右指针指向的字符不是字母或数字，则移动右指针
right--;
}
if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) { // 如果左右指针指向的字符不相同，则返回false
return false;
}
left++; // 移动左指针
right--; // 移动右指针
}
return true;
}public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
int complement = target - nums[i]; // 计算目标值与当前元素的差值
if (map.containsKey(complement)) { // 如果哈希表中存在目标值与当前元素的差值
return new int[] { map.get(complement), i }; // 返回这两个数的索引
}
map.put(nums[i], i); // 将当前元素及其索引添加到哈希表中
}
return new int[] { -1, -1 };
}class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
inorder(root, result);
return result;
}
private void inorder(TreeNode root, List<Integer> result) {
if (root == null) {
return;
}
inorder(root.left, result);
result.add(root.val);
inorder(root.right, result);
}
}回溯算法是一种通过构建决策树来解决问题的算法。它通过逐步构建决策树，并在每个节点进行选择，然后递归地解决子问题，最后回溯到根节点，得到最终的解。
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}邻接矩阵：是图的另一种表示方式，它是一个二维数组，其中每个元素表示两个节点之间是否有边。
邻接表：是图的另一种表示方式，它是一个链表，其中每个节点表示一个顶点，每个节点包含一个指向其他节点的指针。
public void reverseString(char[] s) {
int l = 0;
int r = s.length - 1;
while(l < r){
char temp = s[l];
s[l] = s[r];
s[r] = temp;
l++;
r--;
}
}int lens=temperatures.length;
int []res=new int[lens];
Deque<Integer> stack=new LinkedList<>();
stack.push(0);
for(int i=1;i<lens;i++){
if(temperatures[i]<=temperatures[stack.peek()]){
stack.push(i);
}else{
while(!stack.isEmpty()&&temperatures[i]>temperatures[stack.peek()]){
res[stack.peek()]=i-stack.peek();
stack.pop();
}
stack.push(i);
}
}
return res;