剑指Offer三天挑战赛16~32

文章目录

剑指 Offer 16. 数值的整数次方
- 解
剑指 Offer 17. 打印从1到最大的n位数
- 解
剑指 Offer 18. 删除链表的节点
- 解
剑指 Offer 19. 正则表达式匹配
- 解
剑指 Offer 20. 表示数值的字符串
- 解
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
- 解
剑指 Offer 22. 链表中倒数第k个节点
- 解
剑指 Offer 24. 反转链表
- 解
剑指 Offer 25. 合并两个排序的链表
- 解
剑指 Offer 26. 树的子结构
解
剑指 Offer 27. 二叉树的镜像
- 解
剑指 Offer 28. 对称的二叉树
- 解
剑指 Offer 29. 顺时针打印矩阵
- 解
剑指 Offer 30. 包含min函数的栈
- 解
剑指 Offer 31. 栈的压入、弹出序列
- 解
剑指 Offer 32 - I. 从上到下打印二叉树
- 解

剑指 Offer 16. 数值的整数次方

实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。

示例 1:

输入: 2.00000, 10
输出: 1024.00000
示例 2:

输入: 2.10000, 3
输出: 9.26100
示例 3:

输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-zhi-de-zheng-shu-ci-fang-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

首先如果n为0.直接返回1, 注意这里有一个测试用例是n = -2147483648n=−2147483648 时执行 n = -nn 会因越界而赋值出错。解决方法是先将 n 存入 long 变量 b ，后面用 b 操作即可。那么如果b<0就执行一些变化,然后就是用二进制思想, 比如二进制第一位是X的0次方,第二位是X的1次方,那么我们就看b那些二进制位是1,则表示这个位置上成立

class Solution {public double myPow(double x, int n) {if (n == 0) {return 1;}double ret = 1;long b = n;if (b < 0) {x = 1/x;b = -b;}while (b > 0) {if ((b & 1) == 1) ret *= x;x *= x;b = b >> 1; }return ret;}
}

剑指 Offer 17. 打印从1到最大的n位数

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。

示例 1:

输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/da-yin-cong-1dao-zui-da-de-nwei-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

这道题很没有技术含量, 应该考虑大数的,我后面考虑大数自己做一下

class Solution {public int[] printNumbers(int n) {int max = (int)Math.pow(10, n) - 1;int[] ans = new int[max];for (int i = 1; i <= max; i++) {ans[i - 1] = i;}return ans;}
}

这就是一个全排列的问题,并且使用字符串表示数据,就可以避免大数问题

    private char[] nums = new char[] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};public String printBigNumbers(int n) {StringBuilder builder = new StringBuilder();dfs(0, n, builder, new char[n]);return builder.toString();}private void dfs(int temp, int index, StringBuilder builder, char[] chars) {if (temp == index) {StringBuilder str = new StringBuilder();for (int i = 0; i < chars.length; i++) {if (chars[i] != '0') {for (int j = i; j < chars.length; j++) {str.append(chars[j]);}break;}}if (str.length() != 0) {builder.append(str).append(',');}return;}for (char num : nums) {chars[temp] = num;dfs(temp + 1, index, builder, chars);}}

剑指 Offer 18. 删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。
示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

使用一个假头结点,pre表示新链表节点的指针, 然后循环head,只要head的val == val 就说明该删,就让per.neax = head.next即可, 否则往下遍历,

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode(int x) { val = x; }* }*/
class Solution {public ListNode deleteNode(ListNode head, int val) {ListNode newHead = new ListNode(0);ListNode pre = newHead;while (head != null) {if (head.val == val) {pre.next = head.next;break;}pre.next = head;head = head.next;pre = pre.next;}return newHead.next;}
}

剑指 Offer 19. 正则表达式匹配

请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。

示例 1:

输入:
s = “aa”
p = “a”
输出: false
解释: “a” 无法匹配 “aa” 整个字符串。
示例 2:

输入:
s = “aa”
p = “a*”
输出: true
解释: 因为 ‘*’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zheng-ze-biao-da-shi-pi-pei-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

这道题还是稍微有点难度的,思路就是首先判断p是否为空,如果为空,就看s是否为空,
其次看在s不为空的前提下,s和p的第一个字符是否相等
如果p的长度大于1并且第二个字符为*, 再次分为如果第一个字符相等,说明有俩种情况, 一是s的第一个字符对于p有多个, 二是s的第一个字符在p的*后面还有一个, 说以使用||符号, 如果第一个字符不相等, 说明对于p的第一个字符只出现了0次
如果p的长度不是2或者第二个字符不是*, 又分为俩种情况, 一是第一个字符相等, 那直接在递归判断第二个字符是否相等, 如果此时第一个字符不相等, 直接返回false

class Solution {public boolean isMatch(String s, String p) {if (p.isEmpty()) {return s.isEmpty();}boolean key = !s.isEmpty() && ((s.charAt(0) == p.charAt(0)) || p.charAt(0) == '.');if (p.length() > 1 && p.charAt(1) == '*') {if (key) {return isMatch(s, p.substring(2)) || isMatch(s.substring(1), p);} else {return isMatch(s, p.substring(2));}} else {if (key) {return isMatch(s.substring(1), p.substring(1));} else {return false;}}}
}

剑指 Offer 20. 表示数值的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100"、“5e2”、"-123"、“3.1416”、"-1E-16"、“0123"都表示数值，但"12e”、“1a3.14”、“1.2.3”、"±5"及"12e+5.4"都不是。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/biao-shi-shu-zhi-de-zi-fu-chuan-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

对源字符串进行trim去掉空格, 然后遍历字符串中的每个字符, 具体细节下面代码中有讲解

    public boolean isNumber(String s) {if(s == null || s.length() == 0){return false;}//标记是否遇到相应情况boolean numSeen = false;boolean dotSeen = false;boolean eSeen = false;char[] str = s.trim().toCharArray();for(int i = 0;i < str.length; i++){if(str[i] >= '0' && str[i] <= '9'){numSeen = true;}else if(str[i] == '.'){//.之前不能出现.或者eif(dotSeen || eSeen){return false;}dotSeen = true;}else if(str[i] == 'e' || str[i] == 'E'){//e之前不能出现e，必须出现数if(eSeen || !numSeen){return false;}eSeen = true;numSeen = false;//重置numSeen，排除123e或者123e+的情况,确保e之后也出现数}else if(str[i] == '-' || str[i] == '+'){//+-出现在0位置或者e/E的后面第一个位置才是合法的if(i != 0 && str[i-1] != 'e' && str[i-1] != 'E'){return false;}}else{//其他不合法字符return false;}}return numSeen;}

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/diao-zheng-shu-zu-shun-xu-shi-qi-shu-wei-yu-ou-shu-qian-mian-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

这道题有俩种解法,一个是使用双重暴力解决, 但是效率太低,第二种就是使用这下面这种双下标,左下标指向偶数,右下标指向奇数,然后互换数值

class Solution {public int[] exchange(int[] nums) {if (nums == null) {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 == 0) {right--;}if (left < right) {int temp = nums[left];nums[left] = nums[right];nums[right] = temp;}}return nums;}
}

剑指 Offer 22. 链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

使用双指针, 俩个指针相差就是倒数节点的距离,然后一起走, 知道快指针走到最后一个, 然后慢指针就是想要的那个指针

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode(int x) { val = x; }* }*/
class Solution {public ListNode getKthFromEnd(ListNode head, int k) {if (k < 1) {return null;}ListNode node = head;while (k-- > 1) {node = node.next;}while (node.next != null) {node = node.next;head = head.next;}return head;}
}

剑指 Offer 24. 反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

使用三指针, 第二个指针主要为了反转方向, 所以while主要是第二个指针为null时结束, 第三个指针是为了保留下一个节点,第一个指针记着一开始要让其next为null,最后返回第一个指针就行

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode(int x) { val = x; }* }*/
class Solution {public ListNode reverseList(ListNode head) {if (head == null || head.next == null) {return head;}ListNode node = head.next;head.next = null;while (node != null) {ListNode cur = node.next;node.next = head;head = node;node = cur;}return head;}
}

剑指 Offer 25. 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

看一眼代码就懂

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode(int x) { val = x; }* }*/
class Solution {public ListNode mergeTwoLists(ListNode l1, ListNode l2) {ListNode tempHead = new ListNode(0);ListNode cur = tempHead;while (l1 != null && l2 != null) {if (l1.val < l2.val) {cur.next = l1;l1 = l1.next;} else {cur.next = l2;l2 = l2.next;}cur = cur.next;}if (l1 != null) {cur.next = l1;}if (l2 != null) {cur.next = l2;}return tempHead.next;}
}

剑指 Offer 26. 树的子结构

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)

B是A的子结构，即 A中有出现和B相同的结构和节点值。

例如:
给定的树 A:

 3
/ \

4 5
/
1 2
给定的树 B：

4
/
1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-de-zi-jie-gou-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

完全的暴力递归,题中说明空树不是任何一棵树的子树, 那么只要a和b由一方为空就是false, 然后使用三方递归处理, 一方表示假设此时就是a和b就是相同的根节点,第二方表示是其左子树,第三方表示是其右子树
对于fun函数,他就是判断此时是否为子树,如果b为null说明是, 如果a为null说明不是,如果值相同就递归处理左子树是否相同和右子树是否相同,否则直接返回false

/*** 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;}return fun(A, B) || isSubStructure(A.left, B) || isSubStructure(A.right, B);}private boolean fun(TreeNode A, TreeNode B) {if (B == null) {return true;}if (A == null) {return false;}if (A.val == B.val) {return fun(A.left, B.left) && fun(A.right, B.right);} else {return false;}}
}

剑指 Offer 27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：

/
2 7
/ \ /
1 3 6 9
镜像输出：

/
7 2
/ \ /
9 6 3 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

很简单啦, 你把左子树和右子树交换一下就行, 然后递归处理左子树节点和右子树节点就行

/*** 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;}TreeNode temp = root.left;root.left = root.right;root.right = temp;mirrorTree(root.left);mirrorTree(root.right);return root;}
}

剑指 Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

/
2 2
/ \ /
3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

/
2 2
\
3 3

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

判断是否为对称二叉树, 其实左右就是看根节点的左右子树,如果子树都为null返回true, 如果有一个为null返回false, 如果值不相等,返回false, 最后再递归遍历他的左子树和右子树

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public boolean isSymmetric(TreeNode root) {if (root == null) {return true;}return fun(root.left, root.right);}private boolean fun(TreeNode leftNode, TreeNode rightNode) {if (leftNode == null && rightNode == null) {return true;}if (leftNode == null || rightNode == null) {return false;}if (leftNode.val != rightNode.val) {return false;}return fun(leftNode.left, rightNode.right) && fun(leftNode.right, rightNode.left);}
}

剑指 Offer 29. 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shun-shi-zhen-da-yin-ju-zhen-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

这道题很有意思, 注意是使用的row和col是计算机下标长度,一开始判断结束函数,如果start>col || start > row || col < 0 || row < 0, 说明下标异常了结束方法, 然后每次顺时针循环打印数据, 还有一个注意点就是如果此时行数只有一行,或者列数只有一列,那就后俩个循环不执行, 最递归打印

class Solution {private int[] ans;private int index = 0;public int[] spiralOrder(int[][] matrix) {if (matrix == null || matrix.length == 0) {return new int[0];}int row = matrix.length;int col = matrix[0].length;ans = new int[row * col];fun(matrix, 0, col - 1, row - 1);return ans;}private void fun(int[][] matrix, int start, int col, int row) {if (start > col || start > row || col < 0 || row < 0) {return;}//打印第一行for (int i = start; i <= col; i++) {ans[index++] = matrix[start][i];}//打印最后第一列for (int i = start + 1; i <= row; i++) {ans[index++] = matrix[i][col];}//打印最后一行for (int i = col - 1; (i >= start) && (row > start); i--) {ans[index++] = matrix[row][i];}//打印第一列for (int i = row - 1; (i > start) && (col > start); i--) {ans[index++] = matrix[i][start];}fun(matrix, start + 1, col - 1, row - 1);}
}

剑指 Offer 30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.min(); --> 返回 -2.

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/bao-han-minhan-shu-de-zhan-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

使用俩个栈实现,一个栈正常用, 另一个保存最小值, 看代码一眼就懂

class MinStack {/** initialize your data structure here. */Stack<Integer> stack;Stack<Integer> min;public MinStack() {stack = new Stack<>();min = new Stack<>();}public void push(int x) {stack.push(x);if (min.isEmpty()) {min.push(x);} else {int num = min.peek();if (num < x) {min.push(num);} else {min.push(x);}}}public void pop() {stack.pop();min.pop();}public int top() {return stack.peek();}public int min() {return min.peek();}
}/*** 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.min();*/

剑指 Offer 31. 栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/zhan-de-ya-ru-dan-chu-xu-lie-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

额外使用一个栈,遍历入栈顺序入栈, 如果此时的栈的元素等于此时的出栈元素, 就让其出栈, 当遍历完入栈顺序之后,看额外的栈是否为空

class Solution {public boolean validateStackSequences(int[] pushed, int[] popped) {Stack<Integer> stack = new Stack<>();int index = 0;for (int num : pushed) {stack.push(num);while (!stack.isEmpty() && stack.peek() == popped[index]) {stack.pop();index++;}}return stack.isEmpty();}
}

剑指 Offer 32 - I. 从上到下打印二叉树

从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

例如:
给定二叉树: [3,9,20,null,null,15,7],

/
9 20
/
15 7
返回：

[3,9,20,15,7]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解

这道题其实就是一个简单的层序遍历,没啥难的

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {public int[] levelOrder(TreeNode root) {if (root == null) {return new int[0];}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);List<Integer> list = new ArrayList<>();while (!queue.isEmpty()) {int size = queue.size();while (size-- > 0) {TreeNode cur = queue.poll();list.add(cur.val);if (cur.left != null) {queue.offer(cur.left);}if (cur.right != null) {queue.offer(cur.right);}}}int[] ans = new int[list.size()];for (int i = 0; i < ans.length; i++) {ans[i] = list.get(i);}return ans;}
}