- 博客(150)
- 收藏
- 关注
RSS订阅原创 剑指 Offer 36. 二叉搜索树与双向链表
原题链接在主函数中，递归操作之后，将pre.right = head, head.left = pre含义是将收尾连接起来在递归函数中，终止条件是当cur 为null的时候（如上图2）使用中序遍历来操作if（pre == null）head = cur； 当一开始的时候，pre 为null，此时使用 head 来记录cur，因为之后要返回head具体的实现过程见（图3）class Solution { Node head, pre; public Node treeTo...
2022-04-28 14:27:47
703
原创 剑指 Offer 35. 复杂链表的复制
原题链接class Solution { public Node copyRandomList(Node head) { if(head == null) return null; Node cur = head; //新建一个哈希表 Map<Node,Node> map = new HashMap<>(); while(cur != null){ map.put(cu.
2022-04-28 13:32:01
561
原创 剑指 Offer 34. 二叉树中和为某一值的路径
原题链接class Solution { List<List<Integer>> res = new ArrayList<>(); LinkedList<Integer> path = new LinkedList<>(); public List<List<Integer>> pathSum(TreeNode root, int target) { if(root == null.
2022-04-27 19:28:08
473
原创 剑指 Offer 33. 二叉搜索树的后序遍历序列
原题链接首先定义一个栈定义最大数root进行操作，将数组的值从后向前遍历若出现当前的值大于root的情况，则直接return false；因为这样是不满足后序遍历要求的判断当栈非空，并且stack.peek() > postorder[i] 的时候，将root置为stack.pop();否则直接将stack.add(postorder[i])class Solution { public boolean verifyPostorder(int[] postorder) {.
2022-04-27 19:03:54
827
原创 剑指 Offer 32 - I. 从上到下打印二叉树、剑指 Offer 32 - III. 从上到下打印二叉树 III
原题链接class Solution { public int[] levelOrder(TreeNode root) { List<Integer> list = new ArrayList<>(); if(root == null) return new int[0]; LinkedList<TreeNode> que = new LinkedList<>(); que.offer.
2022-04-26 14:15:37
1003
原创 剑指 Offer 31. 栈的压入、弹出序列
原题链接多回顾，记住思路class Solution { public boolean validateStackSequences(int[] pushed, int[] popped) { Stack<Integer> stack = new Stack<>(); int i = 0; for(int num :pushed){ stack.push(num); wh.
2022-04-26 11:27:50
81
原创 剑指 Offer 30. 包含min函数的栈
原题链接主要是在添加函数的位置要注意判断一下B栈的peek元素，及时更新最小值pop 位置也要考虑是否操作B栈的peek元素class MinStack { Stack<Integer> A, B; /** initialize your data structure here. */ public MinStack() { A = new Stack<>(); B = new Stack<>(); .
2022-04-26 11:13:55
92
原创 剑指 Offer 29. 顺时针打印矩阵
原题链接注意：在程序开始的位置要添加判断的条件，否则不通过使用while(true) 的形式来判断，而不要使用while( index < x)的形式在每次收缩之后，判断是否越界的时候，来判断是否要break在判断越界条件的时候，会出现 l = r 或者 t = b 的情况，故要把截止条件限定为 l > r 或者 t > b 等等class Solution { public int[] spiralOrder(int[][] matrix) { i.
2022-04-26 10:31:04
96
原创 剑指 Offer 27. 二叉树的镜像 剑指 Offer 28. 对称的二叉树
原题链接class Solution { public TreeNode mirrorTree(TreeNode root) { //截止条件 if(root == null) return null; TreeNode tmp = root.left; root.left = root.right; root.right = tmp; //如上交换完之后，开始递归操作 root.ri.
2022-04-26 09:59:00
326
原创 剑指 Offer 26. 树的子结构 与LeetCode 572.子树
原题链接class Solution { public boolean isSubStructure(TreeNode A, TreeNode B) { //截止条件 if(A == null || B == null) return false; if(isEqual(A, B)) return true; return isSubStructure(A.left, B) || isSubStructure(A.right, B)
2022-04-26 09:23:22
73
原创 剑指offer 21、22、24、25
原题链接class Solution { public int[] exchange(int[] nums) { int i = 0, j = nums.length - 1, tmp = 0; while(i < j){ while(i < j && (nums[i] & 1) == 1) i++; while(i < j && (nums[j] &.
2022-04-26 09:11:55
95
原创 剑指 Offer 18. 删除链表的节点
原题链接class Solution { public ListNode deleteNode(ListNode head, int val) { ListNode dummy = new ListNode(-1); dummy.next = head; ListNode pre = dummy; ListNode cur = head; while(cur != null){ if(cur..
2022-04-25 11:18:17
581
原创 剑指 Offer 16. 数值的整数次方 剑指 Offer 17. 打印从1到最大的n位数
原题链接使用快速幂解析，二分法的角度使用long 类型的 b 来保存 给定的幂次 n当 给定的幂次 是小于0，则将 x 取倒数，然后将 幂次取反。例如3^(-2)则将 3取倒数 得 (1/3)^2当幂次大于0 的时候，首先判断当前的幂次是否是奇数，可以使用 if((b & 1) == 1) 或者 if((b % 2) == 1) 来判断都可以若为奇数，则res要乘上一个底数x，然后将 x 变更为 x^2 ，再将 幂次右移一位class Solution { publ.
2022-04-25 10:55:25
183
原创 剑指 Offer 15. 二进制中1的个数
原题链接计算n的个数，使用与运算计算n与1的结果然后将n进行无符号右移//计算n的个数，使用与运算计算n与1的结果，然后将n进行无符号右移public class Solution { // you need to treat n as an unsigned value public int hammingWeight(int n) { int res = 0; while(n != 0){ res += n &.
2022-04-25 10:18:16
63
原创 剑指 Offer 14- I. 剪绳子
原题链接前面的乘积 dp[j]（大于等于2段） 乘上 剩下的一段 i-j或者前面是单独的一段j，然后乘上剩下的一段i-jdp五部曲:1.状态定义:dp[i]为长度为i的绳子剪成m段最大乘积为dp[i]2.状态转移:dp[i]有两种途径可以转移得到2.1 由前一个dp[j](i-j)得到,即前面剪了>=2段,后面再剪一段,此时的乘积个数>=3个2.2 前面单独成一段,后面剩下的单独成一段,乘积为j(i-j),乘积个数为2两种情况中取大的值作为dp[i]的值,同时应该遍历所有j,.
2022-04-25 09:53:50
91
原创 剑指 Offer 13. 机器人的运动范围
原题链接使用辅助函数bitSum 来统计当前的数位和是多少如果出现bitSum(i) + bitSum(j) > k 则说明不满足条件给定的行列数位和要小于等于k的限定条件截止条件之后，开始进行具体的操作：即为将刚刚遍历的位置设置为true返回的结果以递归的形式呈现：具体是 1 + 递归的结果，这个1即为当前的满足条件的位置class Solution { public int movingCount(int m, int n, int k) { boolean[.
2022-04-25 09:11:58
91
原创 剑指 Offer 10-12 共四个题
原题链接class Solution { public int fib(int n) { int a = 0, b = 1, sum; for(int i = 0; i < n; i++){ sum = (a + b) % 1000000007; a = b; b = sum; } return a; }}class Solution {.
2022-04-24 12:12:18
112
原创 剑指 Offer 10- I. 斐波那契数列
原题链接class Solution { int mod = (int)1e9+7; public int fib(int n) { if(n <= 1) return n; int a = 0, b = 1; for(int i = 2; i <= n; i++){ int c = a + b; c %= mod; a = b; b.
2022-04-24 10:53:50
50
原创 剑指 Offer 10- I. 斐波那契数列
原题链接class Solution { int mod = (int)1e9+7; public int fib(int n) { if(n <= 1) return n; int a = 0, b = 1; for(int i = 2; i <= n; i++){ int c = a + b; c %= mod; a = b; b.
2022-04-24 10:29:56
62
原创 剑指 Offer 09. 用两个栈实现队列
原题链接class CQueue { LinkedList<Integer> A, B; public CQueue() { A = new LinkedList<Integer>(); B = new LinkedList<Integer>(); } public void appendTail(int value) { A.addLast(value); } publi.
2022-04-24 09:40:12
97
原创 剑指 Offer 07. 重建二叉树
原题链接class Solution { public TreeNode buildTree(int[] preorder, int[] inorder) { return recur(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1); } public TreeNode recur(int[] preorder, int p_start, int p_end, int[] inor.
2022-04-24 09:21:36
1089
原创 剑指 Offer 06. 从尾到头打印链表
原题链接递归实现class Solution { ArrayList<Integer> tmp = new ArrayList<Integer>(); public int[] reversePrint(ListNode head) { recur(head); int[] res = new int[tmp.size()]; for(int i = 0; i < res.length; i++) .
2022-04-24 08:52:54
213
原创 剑指 Offer 05. 替换空格
原题链接class Solution { public String replaceSpace(String s) { StringBuilder sb = new StringBuilder(); char[] arr = s.toCharArray(); for(char x : arr){ if(x == ' '){ sb.append("%20"); }else.
2022-04-24 08:36:50
144
原创 剑指 Offer 04. 二维数组中的查找
原题链接关于使用 连续的if 语句报错问题例如if ( XXX) 操作1if(XXX) 操作2if(XXX) 操作3若使用连续的 if 语句，若第一个if 成立了，则执行了操作1，此时操作1可能使得某些值改变了，可能改变后的值满足了操作2 或者 操作3，因此不满足逻辑，故要使用 if - else if 的形式class Solution { public boolean findNumberIn2DArray(int[][] matrix, int target) { .
2022-04-24 08:32:00
174
原创 剑指 Offer 03. 数组中重复的数字
原题链接class Solution { public int findRepeatNumber(int[] nums) { Set<Integer> set = new HashSet<>(); for(int num : nums) { if(set.contains(num)) return num; set.add(num); } return -1;.
2022-04-24 07:51:21
166
原创 组合 子集 排列 总结
组合普通组合问题这种类型是最基础的类型，在回溯的终止条件中，值需要判断path 的 size 是否和 k 相等即可，相等则使用res 保存当前的 path。在递归过程中 ，递归之前加入 ，递归之后撤销对于计算总和的题目，若给定了数组则都要进行排序组合总和I此时需要计算组合的sum 为 target的情况只有当sum == target 的时候，才保存当前的pathfor 循环中，先判断sum 是否 是 大于 target ，若是，则break递归之前 sum += candid
2022-04-14 14:19:47
331
原创 剑指 Offer 65. 不用加减乘除做加法
原题链接首先计算进位 c然后计算非进位 a ^ b 然后把值赋值给 a用b 来保存 c然后因为此时的进位 b 是非 0 的，所以会进入新的一轮循环，然后又计算一次 进位，此时的再计算就是0了然后计算 a ^ b 此时的 a 是第二步中的 非进位和，而b 是第三步中的进位，二者相异或，即代表进行了结果的相加然后用 b 来保存 当前循环的进位c，但是 进位已经是0 了，所以下一轮循环截止，最终返回 aclass Solution { public int add(int a, int.
2022-03-28 21:43:49
302
原创 剑指 Offer 62. 圆圈中最后剩下的数字
原题链接注意：在模拟的时候，是不断在后面添加新的值class Solution { public int lastRemaining(int n, int m) { int ans = 0; // 最后一轮剩下2个人，所以从2开始反推 //要统计最后剩下的数字是几 (当前index + m) % 上一轮剩余数字的个数 for (int i = 2; i <= n; i++) { ans = (a.
2022-03-27 22:09:04
167
原创 剑指 Offer 15. 二进制中1的个数
原题链接public class Solution { public int hammingWeight(int n) { int res = 0; while(n != 0) { //与运算 相同为1 不同为0，此处即 统计某位是1的个数 /// >>> : 无符号右移，忽略符号位，空位都以0补齐 res += n & 1; n >
2022-03-27 21:37:03
369
原创 关于虚拟头结点笔记
在移除链表中的某元素的题中使用了虚拟头结点在反转链表中没有使用虚拟头结点因为反转链表，若使用了虚拟头结点，则反转后的最后一个节点即 （原来的头结点 ① 之后不再是null，而是dummy节点了，不满足链表的要求）在两两交换头结点的题中，也是用了虚拟头结点因为交换了之后，dummy 不再是指向① 而是指向了②，并不冲突...
2022-03-24 09:48:42
593
原创 队列 Queue 与 栈 Deque
队列 Queue 的相关操作队列就像通道queue.offer(x) 在队列中加入 元素 xqueue.poll() 将队列中的首元素压出queue.peek() 将队列中的首元素取出看一下queue.isEmpty() 判断队列是否为空+++++++++++++++++++++++++++++++++++++++++++++++++++++栈 Stack 的相关操作栈的一头封死stack.push(x) 将元素x 压入栈中stack.pop() 将 尾部元素排出stack.p
2022-03-19 11:20:06
107
原创 LeetCode 225. 用队列实现栈
原题链接在使用队列（先进先出）实现栈的过程中，与前一个用栈实现队列不同此处的push 需要先将元素加入到queue2中，若queue1非空，则将queue1的值依次poll出，然后加入offer到queue2中，然后将queue2和queue1进行交换要实现的栈的pop，即为queue1的poll（）要实现栈的top，即为queue1的peek（）当queue1非空则栈非空class MyStack { Queue<Integer> queue1; // 和栈中保持.
2022-03-19 10:59:48
312
原创 LeetCode 232. 用栈实现队列
原题链接要实现用栈来模拟队列此处默认是没有队列的功能，需要自己来定义一些功能，但是栈的功能是具备的需要两个栈，一个负责加入，一个负责pop（）出定义一个额外的功能函数dumpstackIn（）作用是将stackIn栈中的元素转移到stackOut中当定义队列的push函数时，其实也就是stackIn的push加入函数当定义队列的pop函数时，首先需要将stackIn的元素先加入到stackOut中，因为栈的pop是将头部元素取出，而队列的pop是将尾部元素取出，经过dumpstackIn函数.
2022-03-19 10:00:48
803
原创 LeetCode 28. 实现 strStr() 的 KMP 解法
原题链接使用KMP算法实现 strStr（）关于kmp算法，首先定义了next数组，next数组就是一个前缀表首先定义了getNext 函数来 生成要检测字符串的next数组然后在主函数中进行调用，关于前缀表的使用：每当检测到两个字符不同的时候，就将needle的索引定位到next[j - 1]的位置，然后继续来判断执行，直到 needl 中的下标 为 needle的长度的时候，就停止。class Solution { public int strStr(String haystac.
2022-03-17 12:49:48
218
原创 KMP算法
KMP主要应用在字符串匹配上。KMP的主要思想是当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。所以如何记录已经匹配的文本内容，是KMP的重点，也是next数组肩负的重任。什么是前缀表？？如上的next数组其实就是前缀表作用：前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配关于最长公共前后缀前缀是指不包含最后一个字符的所有以第一个字符开头的连续子串。如下是 字符串 aabaaf 的前缀后缀是指不包.
2022-03-17 11:23:22
661
原创 LeetCode 剑指 Offer 58 - II. 左旋转字符串
原题链接class Solution { public String reverseLeftWords(String s, int n) { int index = n - 1; //其实就是实现 将前 n个字符移动到后面， StringBuilder sb = new StringBuilder(); //首先将s的后面剩余的字符append到sb上 while(n < s.length()){ .
2022-03-16 11:49:19
107
原创 LeetCode 344. 反转字符串
原题链接使用双指针实现class Solution { public void reverseString(char[] s) { /** 使用双指针进行交换 */ int left = 0; int right = s.length -1; while(left < right){ char temp = s[left]; s[left].
2022-03-16 09:13:59
49
原创 LeetCode 18. 四数之和 后来做的
原题链接此题是三数之和的变换不再要求和 为0 ，而是任意的target同理：但是此处需要两层for循环，每一层for循环后都要跟一个去重操作，去重的时候，都要满足当前的位置不是循环开始的位置，即 第一层时，要求i > 0 … 第二层时要求 j > i + 1…之后的操作和之前相同class Solution { public List<List<Integer>> fourSum(int[] nums, int target) { .
2022-03-13 17:27:02
177
原创 LeetCode 15. 三数之和 后来做的
原题链接使用双指针的方法关键是要进行去重，在开始的时候对nums[i] 进行去重，在while循环里，对左右指针进行去重如下三种去重方式各不相同对右指针进行去重的时候，是比较的当前的 nums[right] 和 nums[right - 1] 的关系。原因：因为当前处理的是，最右边的right，他的右边没有值了，所以只能和他左边的比较看是不是重复的，若是重复的则，先right–，等到后面还会right–，则可以直接跳过左侧的重复值。对left指针进行去重的时候，比较的是其前方的指针，原理同上。.
2022-03-13 17:09:20
206
原创 LeetCode 两数之和
使用HashMap的方式注意containkey 的作用是，判断是否有 key为 target - nums[i] 的一项如果有的话，则直接返回 其值（res.get(target - nums[i])）和 当下的 i若没有 则将这个值作为key，当前的下标作为value，存入res中class Solution { public int[] twoSum(int[] nums, int target) { Map<Integer, Integer> res..
2022-03-13 15:23:46
166
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人