九、模拟
剑指 Offer 29. 顺时针打印矩阵
class Solution {
public int[] spiralOrder(int[][] matrix) {
int row = matrix.length;
if(row==0) return new int[]{};
int col = matrix[0].length;
ArrayList<Integer> res = new ArrayList<>();
int num = row * col;
int top = 0;
int left = 0;
int bottom = row - 1;
int right = col - 1;
while (num >= 1) {
for (int j = left; j <= right && num >= 1; j++) {
res.add(matrix[top][j]);
num--;
}
top++;
for (int i = top; i <= bottom && num >= 1; i++) {
res.add(matrix[i][right]);
num--;
}
right--;
for (int j = right; j >= left && num >= 1; j--) {
res.add(matrix[bottom][j]);
num--;
}
bottom--;
for (int i = bottom; i >= top && num >= 1; i--) {
res.add(matrix[i][left]);
num--;
}
left++;
}
return res.stream().mapToInt(x -> x).toArray();
}
}
JZ61 扑克牌顺子 【巧!!!】
要求:空间复杂度 O(1),时间复杂度 O(nlogn),本题也有时间复杂度 O(n)的解法
根据题意,此 5 张牌是顺子的 充分条件 如下:
- 除大小王外,所有牌 无重复 ;
- 设此 5张牌中最大的牌为 max ,最小的牌为 min (大小王除外),则需满足:
max - min < 5
复杂度分析:
时间复杂度O(NlogN)=O(5log5)=O(1)
: 其中 N为 nums 长度,本题中N=5 ;数组排序使用 O(NlogN)
时间。
空间复杂度 O(1) : 变量joker 使用 O(1) 大小的额外空间。
import java.util.*;
public class Solution {
public boolean IsContinuous(int [] numbers) {
int n = numbers.length;
int queen=0;
Arrays.sort(numbers);
for (int i = 0; i < n-1; i++) {
if(numbers[i]==0) queen++;
else if(numbers[i+1]==numbers[i])
return false;
}
return numbers[n-1]-numbers[queen]<5;
}
}
JZ67 把字符串转换成整数(atoi)
方法一:遍历法(推荐使用)
import java.util.*;
public class Solution {
public int StrToInt (String s) {
int index = 0;
int n = s.length();
int res = 0;
while (index < n) {
if (s.charAt(index) == ' ')
index++;
else break;
}
if (index == n)
return 0;
int sign = 1;
if (s.charAt(index) == '+')
index++;
else if (s.charAt(index) == '-') {
index++;
sign = -1;
}
if (index == n)
return 0;
while (index < n && s.charAt(index)<='9' && s.charAt(index)>='0') {
char ch = s.charAt(index);
if (res > (Integer.MAX_VALUE -(ch-'0'))/10)
return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
res = res * 10 + (ch-'0');
index++;
}
return res*sign;
}
}
JZ20 表示数值的字符串 【难!!!】
进阶:时间复杂度O(n) ,空间复杂度O(n)
解题思路:
* 分析:整体分两种
* A[.[B]][e|EC] .B[e|EC]
*
* A:整数,可正可负
* B:整数,只能正
* C:整数,可正可负
数字的格式可以用A[.[B]][e|EC]或者.B[e|EC]表示
其中A和C都是整数(可以有正负号,也可以没有),而B是一个无符号整数
总共有三种形式 A[.[B]][e|EC] .B[e|EC] A[e|EC]
class Solution {
int index;
int n;
public boolean isNumber(String s) {
n = s.length();
if (n == 0) return false;
index = 0;
while (index < n && s.charAt(index) == ' ') {
index++;
if (index == n) return false;
}
// 判断小数之前的部分
boolean isNum = scanInteger(s);
if (index < n && s.charAt(index) == '.') {
index++;
// 判断小数之后的部分
isNum = scanUnsignedInteger(s) || isNum ;
}
if (index < n && (s.charAt(index) == 'e' || s.charAt(index) == 'E')) {
index++;
isNum = isNum && scanInteger(s);
}
while (index < n && s.charAt(index) == ' ') {
index++;
if (index == n) break;
}
return index == n && isNum;
}
// 判断带符号整数
private boolean scanInteger(String s) {
if (index < n && (s.charAt(index) == '-' || s.charAt(index) == '+')) {
index++;
}
return scanUnsignedInteger(s);
}
// 判断无符号整数
private boolean scanUnsignedInteger(String s) {
int cur = index;
while (index < n && s.charAt(index) >= '0' && s.charAt(index) <= '9') {
index++;
}
return index > cur;
}
}
十、数组
JZ21 调整数组顺序使奇数位于偶数前面(一)
要求:时间复杂度 O(n),空间复杂度 O(n)
进阶:时间复杂度 O(n^2),空间复杂度 O(1)
方式二:快慢指针
class Solution {
public int[] exchange(int[] nums) {
int n = nums.length;
int right = 0;
int left = 0;
while (right < n) {
if (nums[right] % 2 != 0) {
swap(nums, left, right);
left++;
}
right++;
}
return nums;
}
private void swap(int[] nums, int left, int right) {
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
}
}
JZ81 调整数组顺序使奇数位于偶数前面(二)
思想:快慢指针。
import java.util.*;
public class Solution {
public int[] reOrderArrayTwo (int[] array) {
int n = array.length;
for (int i = 0, j = 0; i < n; i++) {
if (array[i] % 2 != 0) {
int tmp = array[i];
array[i] = array[j];
array[j++] = tmp;
}
}
return array;
}
}
JZ39 数组中出现次数超过一半的数字
方式一:
空间复杂度:O(1),时间复杂度 O(n)
摩尔投票法(Boyer–Moore majority vote algorithm),也被称作「多数投票法」,算法解决的问题是:如何在任意多的候选人中(选票无序),选出获得票数最多的那个。
算法可以分为两个阶段:
对抗阶段:分属两个候选人的票数进行两两对抗抵消
计数阶段:计算对抗结果中最后留下的候选人票数是否有效
思想:【擂主和擂主的个数!!】
候选人(cand_num)初始化为nums[0],票数count初始化为1。
当遇到与cand_num相同的数,则票数count = count + 1,否则票数count = count - 1。
当票数count为0时,更换候选人,并将票数count重置为1。
遍历完数组后,cand_num即为最终答案。
import java.util.*;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
int n = nums.length;
// candidate擂主
int candidate = nums[0];
// 表示擂台上擂主的个数
int count = 1;
// 数组中的所有数字开始轮番上擂台进行挑战,每个数字的战斗力均为 1
// 1、相同势力的数字可以都停留在擂台上
// 2、不同势力的数字会同归于尽
for (int i = 1; i < n; i++) {
// 擂台上没有擂主时,那么当前arr[i]就是擂主
if (count == 0)
candidate = nums[i];
//如果擂台上有擂主,而且和当前擂主同类,则votes+1,否则votes-2
if (nums[i] == candidate) {
count++;
} else {
count--;
}
}
return candidate;
}
}
JZ43 整数中1出现的次数
进阶:空间复杂度 O(1) ,时间复杂度 O(lognn)
思路:数位dp
class Solution {
public int countDigitOne(int n) {
int res = 0;
int base = 1;
int a = n / 10;
int b = 0;
int cur = n % 10;
while (base<=n) {
if (cur > 1) {
res += (a + 1) * base;
} else if (cur < 1) {
res += a * base;
} else {
res += a * base + (b + 1);
}
b += cur * base;
cur = a % 10;
a = a / 10;
base *= 10;
}
return res;
}
}
public class Solution {
public int NumberOf1Between1AndN_Solution(int n) {
int res = 0;
int base = 1;
while (base <= n) {
int a = n / base / 10;
int b = n % base;
int cur = n / base % 10;
if (cur > 1) {
res += (a + 1) * base;
} else if (cur == 1) {
res += a * base + b + 1;
} else {
res += a * base;
}
base *= 10;
}
return res;
}
}
JZ45 把数组排成最小的数
方法一:重载比较的排序(推荐使用)
具体做法:
-
step 1:优先判断空数组的特殊情况。
-
step 2:将数组中的数字元素转换成字符串类型。
-
step 3:重载排序比较为字符串类型的x + y < y + x,然后进行排序。
-
step 4:将排序结果再按照字符串拼接成一个整体。
复杂度分析:
时间复杂度 O(NlogN) : N 为 nums数组的长度 ;使用内置函数的平均时间复杂度为 O(NlogN) ,最差为 O(N 2 ) 。
空间复杂度 O(N) : 字符串数组 nums占用线性大小的额外空间。
public class Solution {
public String PrintMinNumber(int [] numbers) {
int n = numbers.length;
if (numbers.length == 0)
return "";
String[] nums = new String[numbers.length];
for (int i = 0; i < n; i++) {
// nums[i]=String.valueOf(numbers[i]);
nums[i] = numbers[i] + "";
}
//根据指定比较器产生的顺序对指定对象数组进行排序。
//此处比较器对象中的泛型和下面参数的类型是一致的,
//如果不指定泛型,那么下面的参数使用具体类型,会报错
//nums也是string类型
//注意要想自定义排序规则,就不能使用基本数据类型int,double ,char
Arrays.sort(nums, new Comparator<String>() {
public int compare(String s1, String s2) {
//compareTo属于字符串方法
return (s1 + s2).compareTo(s2 + s1);
}
});
StringBuilder res = new StringBuilder();
for (int i = 0; i < n; i++) {
res.append(nums[i]);
}
return res.toString();
}
}
JZ49 丑数
class Solution {
public boolean isUgly(int n) {
if (n<=0)
return false;
int[] facotrs={2,3,5};
for (int facotr : facotrs) {
while (n%facotr==0){
n=n/facotr;
}
}
return n==1;
}
}
class Solution {
// 有序数组直接二分
public int missingNumber(int[] nums) {
int left = 0, right = nums.length - 1;
// 下雨等于
while(left <= right) {
// 防溢出的写法,位运算提速,这里注意位运算的优先级问题,需要用括号括起来
int mid = left + ((right - left) >> 1);
if(nums[mid] == mid) left = mid + 1;
else right = mid - 1;
}
return left;
}
}
剑指 Offer 53 - II. 0~n-1中缺失的数字
class Solution {
// 有序数组直接二分
public int missingNumber(int[] nums) {
int left = 0, right = nums.length - 1;
// 下雨等于
while(left <= right) {
// 防溢出的写法,位运算提速,这里注意位运算的优先级问题,需要用括号括起来
int mid = left + ((right - left) >> 1);
if(nums[mid] == mid) left = mid + 1;
else right = mid - 1;
}
return left;
}
}
JZ74 和为S的连续正数序列
方法二:滑动窗口(双指针)
import java.util.ArrayList;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer>> res = new ArrayList<>();
int i = 1, j = 2, s = 3;
while (i < j) {
if (s == sum) {
ArrayList<Integer> tmp = new ArrayList<>();
for (int k = i; k <= j; k++) {
tmp.add(k);
}
res.add(tmp);
}
if (s > sum) {
s -= i;
i++;
} else {
j++;
s += j;
}
}
return res;
}
}
import java.util.*;
public class Solution {
public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
ArrayList<ArrayList<Integer>> res = new ArrayList<>();
int i = 1, j = 2;
int s = 3;
while (i <= sum / 2) {
if (s == sum) {
ArrayList<Integer> tmp = new ArrayList<>();
for (int k = i; k <= j; k++) {
tmp.add(k);
}
res.add(tmp);
s -= i;
i++;
} else if (s < sum) {
j++;
s += j;
} else {
s -= i;
i++;
}
}
return res;
}
}
JZ57 和为S的两个数字
import java.util.*;
public class Solution {
public ArrayList<Integer> FindNumbersWithSum(int [] array, int sum) {
ArrayList<Integer> res = new ArrayList<>();
HashMap<Integer, Integer> map = new HashMap();
int n = array.length;
for (int i = 0; i < n; i++) {
//注意此处的操作!!
int num = sum - array[i];
if (!map.containsKey(num)) {
map.put(array[i], i);
} else {
res.add(num);
res.add(array[i]);
break;
}
}
return res;
}
}
JZ58左旋转字符串
方法一:三次反转(推荐使用)
class Solution {
public String reverseLeftWords(String s, int k) {
int n = s.length();
char[] chars = s.toCharArray();
reverse(chars, 0, n - 1);
reverse(chars, 0, n - k - 1);
reverse(chars, n - k, n-1);
return new String(chars);
}
private void reverse(char[] arr, int i, int j) {
while (i < j) {
char tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
}
}
JZ75 字符流中第一个不重复的字符
方法一:哈希表+字符串(推荐使用)
具体做法:
- step 1:准备一个字符串来记录输入的字符流,用哈希表统计每个字符的次数,二者都是全局变量。
- step 2:在Insert函数中对输入的字符,加到字符串最后,然后统计出现次数。
- step 3:在FirstAppearingOnce函数遍历该字符串,对于每个字符查找哈希表,返回第一个计数为1的字符,如果遍历完字符串以后都没,则返回#。
JZ14 剪绳子
进阶:空间复杂度 O(1),时间复杂度 O(n)
方法一:动态规划(推荐使用)
用dp[i]表示长度为i的绳子可以被剪出来的最大乘积
dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
解题思路:
1、我们想要求长度为n的绳子剪掉后的最大乘积,可以从前面比n小的绳子转移而来
2、用一个dp数组记录从0到n长度的绳子剪掉后的最大乘积,也就是dp[i]表示长度为i的绳子剪成m段后的最大乘积,初始化dp[2] = 1
3、我们先把绳子剪掉第一段(长度为j),如果只剪掉长度为1,对最后的乘积无任何增益,所以从长度为2开始剪
4、剪了第一段后,剩下(i - j)
长度可以剪也可以不剪。如果不剪的话长度乘积即为j * (i - j)
;如果剪的话长度乘积即为j * dp[i - j]
。取两者最大值max(j * (i - j), j * dp[i - j])
5、第一段长度j可以取的区间为[2,i),对所有j不同的情况取最大值,因此最终dp[i]的转移方程为dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
6、最后返回dp[n]
即可
复杂度分析:
- 时间复杂度:O(n^2),两层遍历
- 空间复杂度:O(n),辅助数组dp的空间
class Solution {
public int cuttingRope(int n) {
int[] dp = new int[n + 1];
dp[2] = 1;
// 绳子长度
for (int i = 3; i < n + 1; i++) {
// 段数
for (int j = 1; j < i; j++) {
dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
}
}
return dp[n];
}
}
方法二:贪心(扩展思路)
进阶:空间复杂度 O(1),时间复杂度 O(n)
具体做法:
- step 1:按照上述思路,不超过3的直接计算
- step 2:超过3的不断累乘3,然后number不断减去3,直到最后不超过4。
- step 3:最后乘上剩余的数字。
import java.util.*;
public class Solution {
public int cutRope (int n) {
//不超过3直接计算
if(n <= 3)
return n - 1;
//4比较特殊!!
if(n==4) return 4;
int res=1;
while(n>4){
res*=3;
n-=3;
}
return res*n;
}
}
JZ83 剪绳子(进阶版)
进阶:空间复杂度 O(1) , 时间复杂度 O(logn)
方法一:快速幂+快速乘法
快速幂
class Solution {
int mod = 1000000007;
public int cuttingRope(int n) {
if (n <= 3) return n - 1;
int a = n / 3;
int b = n % 3;
if (b == 0) {
return (int) (pow(3, a) % mod);
} else if (b == 1) {
return (int) (2 * 2 * pow(3, a - 1) % mod);
} else {
return (int) (2 * pow(3, a) % mod);
}
}
// 非递归形式的快速幂
public long pow(long base, int count) {
long res = 1;
while (count > 0) {
if ((count & 1) == 1) {
res = (res * base) % mod;
}
base = (base * base) % mod;
count >>= 1;
}
return res;
}
}
十一、字符串
剑指 Offer 58 - I. 翻转单词顺序
class Solution {
public static String reverseWords(String s) {
String[] strs = s.trim().split(" ");
int n = strs.length;
String res = "";
for (int i = n - 1; i >= 0; i--) {
if (strs[i].equals("")) continue;
res += strs[i];
if (i != 0)
res += " ";
}
return res;
}
}
整理不易🚀🚀,关注和收藏后拿走📌📌欢迎留言🧐👋📣
欢迎专注我的公众号AdaCoding 和 Github:AdaCoding123