基础部分
283. 移动零
简单
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
- 必须在原数组上操作，不能拷贝额外的数组。
- 尽量减少操作次数。
class Solution {
public void moveZeroes(int[] nums) {
if (nums == null || nums.length < 2) return;
int i = 0, len = nums.length, j, tmp;
while (i < len){
while (i < len && nums[i] != 0) i++;
j = i + 1;
while (j < len && nums[j] == 0) j++;
if (j >= len) break;
tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
}
566. 重塑矩阵
简单
在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。
给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。
示例 1:
输入:
nums =
[[1,2],
[3,4]]
r = 1, c = 4
输出:
[[1,2,3,4]]
解释:
行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。
示例 2:
输入:
nums =
[[1,2],
[3,4]]
r = 2, c = 4
输出:
[[1,2],
[3,4]]
解释:
没有办法将 2 * 2 矩阵转化为 2 * 4 矩阵。 所以输出原矩阵。
注意：
- 给定矩阵的宽和高范围在 [1, 100]。
- 给定的 r 和 c 都是正数。
class Solution {
public int[][] matrixReshape(int[][] nums, int r, int c) {
int m = nums.length;
int n = nums[0].length;
if (m * n != r * c) return nums;
int[][] res= new int[r][c];
for (int i = 0; i < r; i++){
for (int j = 0; j < c; j++){
int index = i * c + j;
res[i][j] = nums[index/n][index%n];
}
}
return res;
}
}
485. 最大连续1的个数
简单
给定一个二进制数组， 计算其中最大连续1的个数。
示例 1:
输入: [1,1,0,1,1,1]
输出: 3
解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.
注意：
- 输入的数组只包含
0和1。 - 输入数组的长度是正整数，且不超过 10,000。
class Solution {
public int findMaxConsecutiveOnes(int[] nums) {
int res = nums[0];
for (int i = 1; i < nums.length; i++){
if (nums[i] == 1) {
nums[i] = nums[i-1] + 1;
if (nums[i] > res) res = nums[i];
}
}
return res;
}
}
240. 搜索二维矩阵 II
中等
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：
- 每行的元素从左到右升序排列。
- 每列的元素从上到下升序排列。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix.length == 0 || matrix[0].length == 0) return false;
int row = matrix.length;
int i = 0, j = matrix[0].length - 1;
while (i < row && j >= 0){
if (matrix[i][j] == target) return true;
else if (matrix[i][j] > target) j--;
else i++;
}
return false;
}
}
378. 有序矩阵中第K小的元素
中等
给定一个 n x n 矩阵，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是排序后的第 k 小元素，而不是第 k 个不同的元素。
示例：
matrix = [
[ 1, 5, 9],
[10, 11, 13],
[12, 13, 15]
],
k = 8,
返回 13。
提示：
你可以假设 k 的值永远是有效的，1 ≤ k ≤ n^2 。
class Solution {
public int kthSmallest(int[][] matrix, int k) {
int n = matrix.length;
int[] res = new int[n*n];
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
res[i*n+j] = matrix[i][j];
}
}
Arrays.sort(res);
return res[k-1];
}
}
645. 错误的集合
简单
集合 S 包含从1到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有一个元素重复。
给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。
示例 1:
输入: nums = [1,2,2,4]
输出: [2,3]
注意:
- 给定数组的长度范围是 [2, 10000]。
- 给定的数组是无序的。
class Solution {
public int[] findErrorNums(int[] nums) {
int[] map = new int[nums.length+1];
for (int num : nums) map[num]++;
int[] res = new int[2];
for (int i = 1; i < map.length; i++){
if (map[i] == 1) continue;
else if (map[i] == 2) res[0] = i;
else res[1] = i;
}
return res;
}
}
287. 寻找重复数
中等
给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。
示例 1:
输入: [1,3,4,2,2]
输出: 2
示例 2:
输入: [3,1,3,4,2]
输出: 3
说明：
- 不能更改原数组（假设数组是只读的）。
- 只能使用额外的 O(1) 的空间。
- 时间复杂度小于 O(n2) 。
- 数组中只有一个重复的数字，但它可能不止重复出现一次。
class Solution {
public int findDuplicate(int[] nums) {
int[] map = new int[nums.length];
for (int num : nums){
map[num]++;
if (map[num] == 2) return num;
}
return 0;
}
}
667. 优美的排列 II
中等
给定两个整数 n 和 k，你需要实现一个数组，这个数组包含从 1 到 n 的 n 个不同整数，同时满足以下条件：
① 如果这个数组是 [a1, a2, a3, ... , an] ，那么数组 [|a1 - a2|, |a2 - a3|, |a3 - a4|, ... , |an-1 - an|] 中应该有且仅有 k 个不同整数；.
② 如果存在多种答案，你只需实现并返回其中任意一种.
示例 1:
输入: n = 3, k = 1
输出: [1, 2, 3]
解释: [1, 2, 3] 包含 3 个范围在 1-3 的不同整数， 并且 [1, 1] 中有且仅有 1 个不同整数 : 1
示例 2:
输入: n = 3, k = 2
输出: [1, 3, 2]
解释: [1, 3, 2] 包含 3 个范围在 1-3 的不同整数， 并且 [2, 1] 中有且仅有 2 个不同整数: 1 和 2
提示:
n和k满足条件 1 <= k < n <= 10^4.
class Solution {
public int[] constructArray(int n, int k) {
int[] res = new int[n];
for (int i = 0; i < n; i++) res[i] = i + 1;
int i = 1;
while (--k > 0) reverse(res,i++,n-1);
return res;
}
private void reverse(int[] nums,int l,int r){
int tmp;
while (l < r){
tmp = nums[l];
nums[l] = nums[r];
nums[r] = tmp;
l++;
r--;
}
}
}
697. 数组的度
简单
给定一个非空且只包含非负数的整数数组 nums, 数组的度的定义是指数组里任一元素出现频数的最大值。
你的任务是找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。
示例 1:
输入: [1, 2, 2, 3, 1]
输出: 2
解释:
输入数组的度是2，因为元素1和2的出现频数最大，均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2，所以返回2.
示例 2:
输入: [1,2,2,3,1,4,2]
输出: 6
注意:
nums.length在1到50,000区间范围内。nums[i]是一个在0到49,999范围内的整数。
class Solution {
public int findShortestSubArray(int[] nums) {
Map<Integer,Integer> map = new HashMap<>();
for (int num : nums)
map.put(num,map.getOrDefault(num,0)+1);
List<Integer> maxs = new ArrayList<>();
int maxcount = 0;
for (Integer key : map.keySet()){
maxcount = Math.max(maxcount,map.get(key));
}
if (maxcount < 2) return maxcount;
for (Integer key : map.keySet()){
if (map.get(key) == maxcount) maxs.add(key);
}
int res = nums.length;
for (Integer max : maxs){
int i = 0, j = nums.length-1;
while (nums[i] != max) i++;
while (nums[j] != max) j--;
res = Math.min(res,j-i+1);
}
return res;
}
}
766. 托普利茨矩阵
简单
如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是 托普利茨矩阵 。
给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。
示例 1:
输入:
matrix = [
[1,2,3,4],
[5,1,2,3],
[9,5,1,2]
]
输出: True
解释:
在上述矩阵中, 其对角线为:
"[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]"。
各条对角线上的所有元素均相同, 因此答案是True。
示例 2:
输入:
matrix = [
[1,2],
[2,2]
]
输出: False
解释:
对角线"[1, 2]"上的元素不同。
说明:
matrix是一个包含整数的二维数组。matrix的行数和列数均在[1, 20]范围内。matrix[i][j]包含的整数在[0, 99]范围内。
class Solution {
public boolean isToeplitzMatrix(int[][] matrix) {
int m = matrix.length;
int n = matrix[0].length;
for (int i = 1; i < m; i++){
for (int j = 1; j < n; j++){
if (matrix[i][j] != matrix[i-1][j-1])
return false;
}
}
return true;
}
}
565. 数组嵌套
中等
索引从0开始长度为N的数组A，包含0到N - 1的所有整数。找到最大的集合S并返回其大小，其中 S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }且遵守以下的规则。
假设选择索引为i的元素A[i]为S的第一个元素，S的下一个元素应该是A[A[i]]，之后是A[A[A[i]]]... 以此类推，不断添加直到S出现重复的元素。
示例 1:
输入: A = [5,4,0,3,1,6,2]
输出: 4
解释:
A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.
其中一种最长的 S[K]:
S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
提示：
N是[1, 20,000]之间的整数。A中不含有重复的元素。A中的元素大小在[0, N-1]之间。
class Solution {
public int arrayNesting(int[] nums) {
Set<Integer> set = new HashSet<>();
int res = 1;
for (int i = 0; i < nums.length; i++){
if (set.contains(i)) continue;
int index = i, count = 0;
do {
set.add(index);
index = nums[index];
count++;
}while (index != i);
res = Math.max(res, count);
}
return res;
}
}
769. 最多能完成排序的块
中等
数组arr是[0, 1, ..., arr.length - 1]的一种排列，我们将这个数组分割成几个“块”，并将这些块分别进行排序。之后再连接起来，使得连接的结果和按升序排序后的原数组相同。
我们最多能将数组分成多少块？
示例 1:
输入: arr = [4,3,2,1,0]
输出: 1
解释:
将数组分成2块或者更多块，都无法得到所需的结果。
例如，分成 [4, 3], [2, 1, 0] 的结果是 [3, 4, 0, 1, 2]，这不是有序的数组。
示例 2:
输入: arr = [1,0,2,3,4]
输出: 4
解释:
我们可以把它分成两块，例如 [1, 0], [2, 3, 4]。
然而，分成 [1, 0], [2], [3], [4] 可以得到最多的块数。
注意:
arr的长度在[1, 10]之间。arr[i]是[0, 1, ..., arr.length - 1]的一种排列。
class Solution {
public int maxChunksToSorted(int[] arr) {
int res = 0, max = 0;
for (int i = 0; i < arr.length; i++){
max = Math.max(arr[i], max);
if (max == i) res++; //当前最大值==当前坐标
}
return res;
}
}
频率排序
768，1，945，42，4，1014，85，15，1040，548，918，53，442，45，974，782，54，769，644，713，723，718，873，11，128，714，381，1074，121，56，33，88，123，509，695，84，665，717