😍😍😍 相知

当你踏入计算机科学的大门，或许会感到一片新奇而陌生的领域，尤其是对于那些非科班出身的学子而言。作为一位非科班研二学生，我深知学习的道路可能会充满挑战，让我们愿意迎接这段充满可能性的旅程。

最近，我开始了学习《剑指Offer》和Java编程的探索之旅。这不仅是一次对计算机科学的深入了解，更是对自己学术生涯的一次扩展。或许，这一切刚刚开始，但我深信，通过努力与坚持，我能够逐渐驾驭这门技艺。

在这个博客中，我将深入剖析《剑指Offer》中的问题，并结合Java编程语言进行解析。

让我们一起踏上这段学习之旅，共同奋斗，共同成长。无论你是已经驾轻就熟的Java高手，还是像我一样初出茅庐的学子，我们都能在这里找到彼此的支持与激励。让我们携手前行，共同迎接知识的挑战，为自己的未来打下坚实的基石。

这是我上一篇博客的，也希望大家多多关注！

1. 《剑指Offer》笔记&题解&思路&技巧&优化 Java版本——新版leetcode_Part_1
2. 《剑指Offer》笔记&题解&思路&技巧&优化 Java版本——新版leetcode_Part_2

🙌🙌🙌 相识

根据题型可将其分为这样几种类型：

1. 结构概念类（数组，链表，栈，堆，队列，树）
2. 搜索遍历类（深度优先搜索，广度优先搜索，二分遍历）
3. 双指针定位类（快慢指针，指针碰撞，滑动窗口）
4. 排序类（快速排序，归并排序）
5. 数学推理类（动态规划，数学）

😢😢😢 开始刷题

1. LCR 138. 有效数字——表示数值的字符串

题目跳转：https://leetcode.cn/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof/description/

边界条件很多

学会函数：

1. s = s.trim();
2. char[] res = s.toCharArray();

class Solution {public boolean isNumber(String s) {if (s == null || s.length() == 0) return false;//去掉首尾空格s = s.trim();boolean numFlag = false;boolean dotFlag = false;boolean eFlag = false;for (int i = 0; i < s.length(); i++) {//判定为数字，则标记numFlagif (s.charAt(i) >= '0' && s.charAt(i) <= '9') {numFlag = true;//判定为.  需要没出现过.并且没出现过e} else if (s.charAt(i) == '.' && !dotFlag && !eFlag) {dotFlag = true;//判定为e，需要没出现过e，并且出过数字了} else if ((s.charAt(i) == 'e' || s.charAt(i) == 'E') && !eFlag && numFlag) {eFlag = true;numFlag = false;//为了避免123e这种请求，出现e之后就标志为false//判定为+-符号，只能出现在第一位或者紧接e后面} else if ((s.charAt(i) == '+' || s.charAt(i) == '-') && (i == 0 || s.charAt(i - 1) == 'e' || s.charAt(i - 1) == 'E')) {//其他情况，都是非法的} else {return false;}}return numFlag;}
}

---

2. LCR 139. 训练计划 I——调整数组顺序使奇数位于偶数前面

题目跳转：https://leetcode.cn/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof/description/

class Solution {public int[] trainingPlan(int[] actions) {if(actions==null)return null;if(actions.length==0)return new int[0];int slow = 0;int fast = 0;while(fast<actions.length&&slow<actions.length){if(actions[slow]%2==0){while(fast<actions.length){if(actions[fast]%2==1){int temp = actions[fast];for(int i = fast;i>slow;i--){actions[i] = actions[i-1];}actions[slow] =temp;break;}else fast++;}}slow++;fast++;}return actions;}
}

class Solution {public int[] trainingPlan(int[] nums) {if(nums == null || nums.length == 0){return nums;}int left = 0;int right = nums.length - 1;while(left < right){while(left < right && nums[left] % 2 != 0) left++;while(left < right && nums[right] % 2 != 1) right--;int temp = nums[left];nums[left] = nums[right];nums[right] = temp;}return nums;}
}

---

3. LCR 140. 训练计划 II——链表中倒数第k个节点

题目跳转：https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/description/

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public ListNode trainingPlan(ListNode head, int cnt) {if(head==null) return null;if(head.next == null) return head;ListNode result = head;int num = 0;while(result!=null){num++;result = result.next;}num = num - cnt;while(num!=0){head = head.next;num--;}return head;}
}

来个牛逼的！

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public ListNode trainingPlan(ListNode head, int cnt) {if(head==null) return null;if(head.next == null) return head;ListNode slow = head;ListNode fast = head;for(int i = 0;i<cnt;i++){if(fast==null)return null;fast = fast.next;}while(fast!=null){slow = slow.next;fast = fast.next;}return slow;}
}

---

4. LCR 141. 训练计划 III——反转链表

题目跳转：https://leetcode.cn/problems/fan-zhuan-lian-biao-lcof/description/

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public ListNode trainningPlan(ListNode head) {ListNode result = new ListNode(0);while(head!=null){ListNode temp = head;head = head.next;temp.next= result.next;result.next = temp;}return result.next;}
}

递归

class Solution {public ListNode trainningPlan(ListNode head) {if(head==null||head.next==null)return head;ListNode temp = trainningPlan(head.next);head.next.next = head;head.next= null;return temp;}
}

---

5. LCR 142. 训练计划 IV——合并两个排序的链表

题目跳转：https://leetcode.cn/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/description/

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public ListNode trainningPlan(ListNode l1, ListNode l2) {if(l1==null)return l2;if(l2==null)return l1;ListNode result = new ListNode();ListNode temp = result;while(l1!=null||l2!=null){if(l1!=null&&l2!=null){if(l1.val<l2.val){ListNode res = new ListNode(l1.val);temp.next= res;temp =temp.next;l1 = l1.next;}else{ListNode res = new ListNode(l2.val);temp.next= res;temp =temp.next;l2 = l2.next;}}if(l1==null){temp.next =l2;break; }if(l2==null){temp.next =l1;break; }}return result.next;}
}

递归思路：
我们可以如下递归地定义两个链表里的 merge 操作（忽略边界情况，比如空链表等）：

$$\{\begin{array}{ll}list1[0]+merge(list1[1:],list2)& list1[0]<list2[0]\\ list2[0]+merge(list1,list2[1:])& otherwise\end{array}$$

也就是说，两个链表头部值较小的一个节点与剩下元素的 merge 操作结果合并。

算法

我们直接将以上递归过程建模，同时需要考虑边界情况。

如果 l1 或者 l2 一开始就是空链表 ，那么没有任何操作需要合并，所以我们只需要返回非空链表。否则，我们要判断 l1 和 l2 哪一个链表的头节点的值更小，然后递归地决定下一个添加到结果里的节点。如果两个链表有一个为空，递归结束。

class Solution {public ListNode trainningPlan(ListNode l1, ListNode l2) {if (l1 == null) {return l2;} else if (l2 == null) {return l1;} else if (l1.val < l2.val) {l1.next = trainningPlan(l1.next, l2);return l1;} else {l2.next = trainningPlan(l1, l2.next);return l2;}}
}

---

6. LCR 143. 子结构判断——树的子结构

题目跳转：https://leetcode.cn/problems/shu-de-zi-jie-gou-lcof/description/

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public boolean isSubStructure(TreeNode A, TreeNode B) {if(A==null||B==null)return false;if(isSub(A,B))return true;if(isSubStructure(A.left, B) || isSubStructure(A.right, B)){return true;}return false;}public boolean isSub(TreeNode TA,TreeNode TB){if(TB==null)return true;if(TA==null)return false;if(TA.val!=TB.val)return false;return isSub(TA.left,TB.left)&&isSub(TA.right,TB.right);}
}

---

7. LCR 144. 翻转二叉树——二叉树的镜像

题目跳转：https://leetcode.cn/problems/er-cha-shu-de-jing-xiang-lcof/description/

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public TreeNode mirrorTree(TreeNode root) {if(root==null)return root;if(root.right==null&&root.left==null)return root;TreeNode temp = root.left;root.left = root.right;root.right = temp;root.right = mirrorTree(root.right);root.left = mirrorTree(root.left);return root;}}

---

8. LCR 145. 判断对称二叉树——对称的二叉树

题目跳转：https://leetcode.cn/problems/dui-cheng-de-er-cha-shu-lcof/description/

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode() {}*     TreeNode(int val) { this.val = val; }*     TreeNode(int val, TreeNode left, TreeNode right) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
class Solution {public boolean checkSymmetricTree(TreeNode root) {if(root==null)return true;if(root.left==null&&root.right==null)return true;if(root.right==null||root.left==null)return false;return check(root.left,root.right);}public boolean check(TreeNode A,TreeNode B){if(A==null&&B==null)return true;if(A==null||B==null)return false;if(A.val!=B.val)return false;return check(A.left,B.right)&&check(A.right,B.left);}
}

---

9. LCR 146. 螺旋遍历二维数组——顺时针打印矩阵

题目跳转：https://leetcode.cn/problems/shun-shi-zhen-da-yin-ju-zhen-lcof/description/

算法流程：

• 空值处理： 当 array 为空时，直接返回空列表 [] 即可。
• 初始化： 矩阵 左、右、上、下 四个边界 l , r , t , b ，用于打印的结果列表 res 。
• 循环打印： “从左向右、从上向下、从右向左、从下向上” 四个方向循环打印；
  • 根据边界打印，即将元素按顺序添加至列表 res 尾部；
  • 边界向内收缩 1 （代表已被打印）；
  • 判断边界是否相遇（是否打印完毕），若打印完毕则跳出。
• 返回值： 返回 res 即可。

打印方向	1. 根据边界打印	2. 边界向内收缩	3. 是否打印完毕
从左向右	左边界l ，右边界 r	上边界 t 加 111	是否 t > b
从上向下	上边界 t ，下边界b	右边界 r 减 111	是否 l > r
从右向左	右边界 r ，左边界l	下边界 b 减 111	是否 t > b
从下向上	下边界 b ，上边界t	左边界 l 加 111	是否 l > r

class Solution {public int[] spiralArray(int[][] array) {if(array.length == 0) return new int[0];int l = 0, r = array[0].length - 1, t = 0, b = array.length - 1, x = 0;int[] res = new int[(r + 1) * (b + 1)];while(true) {for(int i = l; i <= r; i++) res[x++] = array[t][i]; // left to rightif(++t > b) break;for(int i = t; i <= b; i++) res[x++] = array[i][r]; // top to bottomif(l > --r) break;for(int i = r; i >= l; i--) res[x++] = array[b][i]; // right to leftif(t > --b) break;for(int i = b; i >= t; i--) res[x++] = array[i][l]; // bottom to topif(++l > r) break;}return res;}
}

按层模拟:

class Solution {public int[] spiralArray(int[][] array) {if (array == null || array.length == 0 || array[0].length == 0) {return new int[0];}int rows = array.length, columns = array[0].length;int[] order = new int[rows * columns];int index = 0;int left = 0, right = columns - 1, top = 0, bottom = rows - 1;while (left <= right && top <= bottom) {for (int column = left; column <= right; column++) {order[index++] = array[top][column];}for (int row = top + 1; row <= bottom; row++) {order[index++] = array[row][right];}if (left < right && top < bottom) {for (int column = right - 1; column > left; column--) {order[index++] = array[bottom][column];}for (int row = bottom; row > top; row--) {order[index++] = array[row][left];}}left++;right--;top++;bottom--;}return order;}
}

复杂度分析

• 时间复杂度：O(mn)，其中 m 和 n 分别是输入二维数组的行数和列数。二维数组中的每个元素都要被访问一次。

• 空间复杂度：O(1)。除了输出数组以外，空间复杂度是常数。

---

10. LCR 147. 最小栈——包含min函数的栈

题目跳转：https://leetcode.cn/problems/bao-han-minhan-shu-de-zhan-lcof/description/

class MinStack {/** initialize your data structure here. */int minstack = Integer.MAX_VALUE;;Stack<Integer> stack;public MinStack() {stack = new Stack<Integer>();}public void push(int x) {stack.push(minstack);minstack = x<minstack?x:minstack;stack.push(x);}public void pop() {stack.pop();minstack = stack.pop();}public int top() {return stack.peek();}public int getMin() {return minstack;}
}/*** Your MinStack object will be instantiated and called as such:* MinStack obj = new MinStack();* obj.push(x);* obj.pop();* int param_3 = obj.top();* int param_4 = obj.getMin();*/

---