文章目录
前言
一、把数组中0移到末尾
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意，必须在不复制数组的情况下原地对数组进行操作。
class Solution {
public void moveZeroes(int[] nums) {
int index=0,len= nums.length;
for(int num :nums){
if(num!=0){
nums[index]=num;
++index;
}
}
while (index<len){
nums[index]=0;
index++;
}
}
}
二、改变矩阵维度
使用函数 reshape ，将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。重构后的矩阵需要将原始矩阵的所有元素以相同的 行遍历顺序 填充。
class Solution {
public int[][] matrixReshape(int[][] mat, int r, int c) {
int m=mat.length,n=mat[0].length;
if(m*n!=r*c) return mat;
int[][] res=new int[r][c];
for(int i=0;i<r;++i)
for(int j=0;j<c;++j){
int t=i*c+j;
int p=t/n,q=t%n; //注意这个关系哈，不然每次还要重新计算，记得n是列哈！！
res[i][j]=mat[p][q];
}
return res;
}
}
三、找出数组中最长的连续1
给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。
class Solution {
public int findMaxConsecutiveOnes(int[] nums) {
int max = 0, cur = 0;
for (int x : nums) {
cur = x == 0 ? 0 : cur + 1;
max = Math.max(max, cur); //边遍历边计算
}
return max;
}
}
四、有序矩阵查找
编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target 。该矩阵具有以下特性：
- 每行的元素从左到右升序排列。
- 每列的元素从上到下升序排列。
class Solution {
public boolean searchMatrix(int[][] matrix, int target) {
if (matrix == null || matrix.length == 0 || matrix[0].length == 0) return false;
int m = matrix.length, n = matrix[0].length;
int row = 0, col = n - 1; //关键在于要从右下角或者左上角开始遍历
while (row < m && col >= 0) {
if (target == matrix[row][col]) return true;
else if (target < matrix[row][col]) col--;
else row++;
}
return false;
}
}
五、有序矩阵中第K小的元素
给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是 排序后 的第 k 小元素，而不是第 k 个不同 的元素。你必须找到一个内存复杂度优于 O(n2) 的解决方案。
题目使用的是二分法，在有序的数字不重复的数组中，小于等于第k个数的的数字一共有k个。
class Solution {
public int kthSmallest(int[][] matrix, int k) {
int m = matrix.length, n = matrix[0].length;
int l = matrix[0][0], r = matrix[m - 1][n - 1];
while (l <= r) {
int mid = l + (r - l) / 2;
int cnt = 0;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n && matrix[i][j] <=mid; j++) {
cnt++;
}
}
if (cnt < k) l = mid + 1;
else r = mid - 1;
}
return l;
}
}
六、错误的集合
集合 s 包含从 1 到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个数字复制了成了集合里面的另外一个数字的值，导致集合 丢失了一个数字 并且 有一个数字重复 。
该方法主要在于要找到题解的特点，例如使用辅助数组记录元素出现的次数，遍历一遍之后“丢失的数字”出现了0次，“重复了一次的数数字”出现次数为2。
//肯定可以使用hash
//或者排序等
//然后就是遍历
class Solution {
public int[] findErrorNums(int[] nums) {
int n=nums.length;
int[] res=new int[2];
int[] cns=new int[n+1];//这里有一个前提，集合s包含的是从1到n的整数
for(int x :nums) cns[x]++;
for(int i=1;i<=n;++i){
if(cns[i]==2) res[0]=i;
if(cns[i]==0) res[1]=i;
}
return res;
}
}
七、找出数组中重复的数，数组值在1~n之间
给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。
假设 nums 只有 一个重复的整数 ，返回 这个重复的数 。
你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。
使用二分法，在有序的数字不重复的数组中，小于等于第k个数的的数字一共有k个。
class Solution {
public int findDuplicate(int[] nums) {
int n = nums.length;
int l = 1, r = n - 1, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (nums[i] <= mid) {
cnt++;
}
}
if (cnt <= mid) {
l = mid + 1;
} else {
r = mid - 1;
ans = mid; //注意ans是在这个部分奥吗，也就是cnt>mid
}
}
return ans;
}
}
快慢指针的方法
class Solution {
public int findDuplicate(int[] nums) {
int slow=0,fast=0;
//这部分可以写成do...while也可以写为：
// do{
// slow=nums[slow];
// fast=nums[nums[fast]];
// }while(slow!=fast);
slow = nums[slow];
fast = nums[nums[fast]];
while(slow != fast){
slow = nums[slow];
fast = nums[nums[fast]];
}
slow=0;
while (slow!=fast){
slow=nums[slow];
fast=nums[fast];
}
return slow;
}
}
插曲之快慢指针的思想
快慢指针最常见的用法是用来查找链表中环的入口。
将链表按照相遇地址分为三段，分别是a、b、c，假设快慢第一次相遇的时候快指针已经走了n圈了，快指针走过的距离是：a+n*（b+c）+b，而慢指针走过的距离是a+b，而且快指针走过的路程是慢指针的两倍，可以得到下面的等式：
a+n*（b+c）+b=2*（a+b）
所以a=(n-1)*(b+c) + c。
所以环的入口位置a，也就是从链表的头部开始走a步的节点，所以让快慢指针或者新建一个指针从链表头部开始走，另一个指针从快慢指针第一次相遇的位置开始走，他们相遇的位置就是环的入口。
关于为什么快慢指针第一次相遇的时候，慢指针一定是还没有走完一圈呢？
我们假设这个环的长度为 x，那么当 slow 指针走完一圈时，需要走 x 步，而当 slow 指针走完 x 步，fast 指针已经走了 2x
步了，也就是走了两圈了，那么他们一定在某一个点相遇过了（因为他们不可能错过相遇点），所以当快慢指针第一次相遇时，慢指针是不可能走完一圈的。
八、数组相邻差值的个数
给你两个整数 n 和 k ，请你构造一个答案列表 answer ，该列表应当包含从 1 到 n 的 n 个不同正整数，并同时满足下述条件：
假设该列表是 answer = [a1, a2, a3, … , an] ，那么列表 [|a1 - a2|, |a2 - a3|, |a3 - a4|, … , |an-1 - an|] 中应该有且仅有 k 个不同整数。返回列表 answer 。如果存在多种答案，只需返回其中 任意一种。
这题技巧性也太强了吧…，下面是官方思路和答案：
class Solution {
public int[] constructArray(int n, int k) {
int[] answer = new int[n];
int idx = 0;
for (int i = 1; i < n - k; ++i) {
answer[idx] = i;
++idx;
}
for (int i = n - k, j = n; i <= j; ++i, --j) {
answer[idx] = i;
++idx;
if (i != j) {
answer[idx] = j;
++idx;
}
}
return answer;
}
}
九、数组的度
给定一个非空且只包含非负数的整数数组 nums，数组的 度 的定义是指数组里任一元素出现频数的最大值。
你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。
class Solution {
public int findShortestSubArray(int[] nums) {
HashMap<Integer,Integer> hashMap=new HashMap<>();
HashMap<Integer,Integer> firstindex=new HashMap<>();
HashMap<Integer,Integer> endindex=new HashMap<>();
int len=nums.length,maxtime=0;
for(int i=0;i<len;++i){
hashMap.put(nums[i],hashMap.getOrDefault(nums[i],0)+1);
endindex.put(nums[i],i);
if(!firstindex.containsKey(nums[i]))
firstindex.put(nums[i],i);
int time=hashMap.get(nums[i]);
if(time>maxtime)
maxtime=time;
}
int res=len;
Iterator iterator=hashMap.keySet().iterator();
while (iterator.hasNext()){
int number=(int) iterator.next();
int t=hashMap.get(number);
if(t==maxtime){
int first=firstindex.get(number);
int end=endindex.get(number);
if(end-first+1<res)
res=end-first+1;
}
}
return res;
}
}
十、对角元素相等的矩阵
如果矩阵上每一条由左上到右下的对角线上的元素都相同，那么这个矩阵是 托普利茨矩阵 。
class Solution {
public boolean isToeplitzMatrix(int[][] matrix) {
int m=matrix.length,n=matrix[0].length;
int i=0,j=0;
for(j=0;j<n;++j){
i=0;
int num=matrix[0][j],jj=j;
while (i<m && jj<n){
if(num!=matrix[i][jj])
return false;
i+=1;
jj+=1;
}
}
for(i=0;i<m;++i){
j=0;
int num=matrix[i][0],ii=i;
while (ii<m && j<n){
if(num!=matrix[ii][j])
return false;
ii+=1;
j+=1;
}
}
return true;
}
}
十一、嵌套数组
索引从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出现重复的元素。
class Solution {
public int arrayNesting(int[] nums) {
int len=nums.length;
int[] flag=new int[len];
int res=0;
for(int i=0;i<len;++i){
if(flag[i]==1)
continue;
int j=nums[i],cur=1;
while (j!=i){
int k=nums[j];
flag[j]=1;
j=k;
++cur;
}
res=Math.max(res,cur);
}
return res;
}
}
十二、分割数组
给定一个长度为 n 的整数数组 arr ，它表示在 [0, n - 1] 范围内的整数的排列。
我们将 arr 分割成若干块 (即分区)，并对每个块单独排序。将它们连接起来后，使得连接的结果和按升序排序后的原数组相同，返回数组能分成的最多块数量。
关键在于要注意数组中元素范围为[0,n-1]，注意元素与其下标的关系。
class Solution {
public int maxChunksToSorted(int[] arr) {
if (arr == null) return 0;
int ret = 0;
int right = arr[0];
for (int i = 0; i < arr.length; i++) {
right = Math.max(right, arr[i]);
if (right == i) ret++;
}
return ret;
}
}
420
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
