作为一个硬核作者，绝不和你扯废话，干货无套路送你
题目一：
给定一个数组arr，求出需要排序的最短子数组长度
要求：
时间o(n),空间o(1)
思路：
有序的数组中，任意一个数字，一定小于左边的数大于右边的数。
我们找到的需要排序的子数组，显然是比右边最小的值大，或比左边最大的值小。
我们初始化变量noMinindex=-1;从右往左遍历，记录经过的最小值为min，若当前数大于min，说明，如果要有序，min一定要放 在当前数左边，我们更新noMinindex。
也就是说，我们的noMinindex是负责记录最左边出现这种情况的位置。我们反方向处理出noMaxindex
他们组成的区间就是最短需要排序的部分了
public class MinLengthForSort {
public static int getMinLength(int[] arr) {
if (arr == null || arr.length < 2) {
return 0;
}
int min = arr[arr.length - 1];
int noMinIndex = -1;
for (int i = arr.length - 2; i != -1; i--) {
if (arr[i] > min) {
noMinIndex = i;
} else {
min = Math.min(min, arr[i]);
}
}
if (noMinIndex == -1) {
return 0;
}
int max = arr[0];
int noMaxIndex = -1;
for (int i = 1; i != arr.length; i++) {
if (arr[i] < max) {
noMaxIndex = i;
} else {
max = Math.max(max, arr[i]);
}
}
return noMaxIndex - noMinIndex + 1;
}
public static void main(String[] args) {
int[] arr = { 1, 2, 4, 7, 10, 11, 7, 12, 6, 7, 16, 18, 19 };
System.out.println(getMinLength(arr));
}
}
题目二：
给定一个数组，找出出现次数超过一半的数字
蠢思路：排序找中间
思路：
DP：扫一遍一个变量count记录解出现的次数，是当前解就++，否则--，count为负就换掉当前解。（解释：想象解全都挨在 一起（前面），count先达到最大，然后减为1或0，而其他数字先出现，可能会使正确解的count减为负数，但都会使正确解 在后面更多，从而保证了结束时肯定为正确解）
int main()
{
int n;//个数
scanf("%d",&n);
int temp,k,count=0;
while(n--)
{
scanf("%d",&temp);
if(temp==k)count++;
else
{
count--;
if(count<0){count=0;k=temp;}
}
}
printf("%d\n",k);
}题目三：
给定一个有N×M的整型矩阵matrix和一个整数K，matrix的每一行和每一列都是排好序的。实现一个函数，判断K是否在matrix中。
例如：
0 1 2 5
2 3 4 7
4 4 4 8
5 7 7 9
如果K为7，返回true，如果K为6，返回false
要求：
时间复杂度为O(N+M)，额外空间复杂度为O(1)。
思路：
1.从矩阵最右上角的数开始寻找（row=0,col=M-1）。
2.比较当前数matrix[row][col]与K的关系：
如果与K相等，说明已找到，直接返回true
如果比K大，因为矩阵每一列都已排好序，所以在当前数所在的列中，处于当前数下方的数都会比K大，则没有必要继续在第col列上寻找，令col=col-1，重复步骤2.
如果比K小，因为矩阵每一行都已排好序，所以在当前数所在的行中，处于当前数左方的数都会比K小，则没有必要继续在第row行上寻找，令row=row+1,重复步骤2.
3.如果找到越界都没有发现与K相等的数，则返回false。
或者可以从矩阵的最左下角的数开始寻找（row=N-1,col=0），具体过程类似。
代码：
/**
* 在行列都排好序的矩阵中找数
*/
public class IsContains {
public boolean isContains(int[][] matrix, int K) {
int row = 0;
int col = matrix[0].length - 1;
while (row < matrix.length && col > -1) {
if (matrix[row][col] == K) {
return true;
} else if (matrix[row][col] > K) {
col--;
} else {
row++;
}
}
return false;
}
}题目四：转圈打印矩阵
题目：
给定一个整型矩阵matrix，请按照转圈的方式打印它。例如：1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,打印结果为：1,2,3,4,5,12,16,15,14,13,9,5,6,7,11,10
要求：
额外空间复杂度为O（1）
思路：
矩阵分圈处理。在矩阵中用左上角的坐标（tR,tC）和右下角的坐标（dR,dC）就可以表示一个矩阵，比如，题目中的矩阵，当（tR,tC）=(0,0)，（dR,dC）=(3,3)时，表示的子矩阵就是整个矩阵，那么这个子矩阵的最外层的部分如下：
1 2 3 4
5 8
9 12
13 14 15 16
如果能把这个子矩阵的外层转圈打印出来，那么在(tR,tC)=(0,0)、(dR,dC)=(3,3)时，打印结果为：1,2,3,4,8,12,16,15,14,13,9,5。接下来令tR和tC加1，即(tR,tC)=(1,1)，令dR和dC减1，即(dR,dC)=(2,2)，此时表示的子矩阵如下：
6 7
10 11
再把这个子矩阵转圈打印出来，结果为：6,7,11,10。把tR和tC加1，即(tR,tC)=(2,2)，令dR和dC减1，即(dR,dC)=(1,1)。如果发现左上角坐标跑到右下角坐标的右方或下方，整个过程就停止。已经打印的所有结果连接起来就是我们要求的打印结果。
代码：
/**
* 转圈打印矩阵
*/
public class PrintMatrixSpiralOrder {
public void spiralOrderPrint(int[][] matrix) {
int tR = 0;
int tC = 0;
int dR = matrix.length - 1;
int dC = matrix[0].length - 1;
while (tR <= dR && tC <= dC) {
printEdge(matrix, tR++, tC++, dR--, dC--);
}
}
//转圈打印一个子矩阵的外层，左上角点（tR,tC），右下角点（dR,dC）
private void printEdge(int[][] matrix, int tR, int tC, int dR, int dC) {
if (tR == dR) {//子矩阵只有一行时
for (int i = tC; i <= dC; i++) {
System.out.print(matrix[tR][i] + " ");
}
} else if (tC == dC) {//子矩阵只有一列时
for (int i = tR; i <= dR; i++) {
System.out.print(matrix[i][tC] + " ");
}
} else {//一般情况
int curCol = tC;
int curRow = tR;
while (curCol != dC) {//从左向右
System.out.print(matrix[tR][curCol] + " ");
curCol++;
}
while (curRow != dR) {//从上到下
System.out.print(matrix[curRow][dC] + " ");
curRow++;
}
while (curCol != tC) {//从右到左
System.out.print(matrix[dR][curCol] + " ");
curCol--;
}
while (curRow != tR) {//从下到上
System.out.print(matrix[curRow][tC] + " ");
curRow--;
}
}
}
}
题目五：将正方形矩阵顺时针转动90°
题目：
给定一个N×N的矩阵matrix，把这个矩阵调整成顺时针转动90°后的形式。
例如：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
顺时针转动90°后为：
13 9 5 1
14 10 6 2
15 11 7 3
16 12 8 4
要求：
额外空间复杂度为O(1).
思路：
仍然使用分圈处理的方式，
在矩阵中用左上角的坐标（tR,tC）和右下角的坐标（dR,dC）就可以表示一个矩阵，比如，题目中的矩阵，当（tR,tC）=(0,0)，（dR,dC）=(3,3)时，表示的子矩阵就是整个矩阵，那么这个子矩阵的最外层的部分如下：
1 2 3 4
5 8
9 12
13 14 15 16
在这个外圈中，1,4,16,13为一组，然后让1占据4的位置，4占据16的位置，16占据13的位置，13占据1的位置，一组就调整完了。然后2,8,15,9为一组，继续占据调整的过程，最后3,12,14,5为一组，继续占据调整的过程。然后(tR,tC)=(0,0)、(dR,dC)=(3,3)的子矩阵外层就调整完毕，接下来令tR和tC加1，即(tR,tC)=(1,1)，令dR和dC减1，即（dR,dC）=(2,2)，此时表示的子矩阵如下：
6 7
10 11
这个外层只有一组，就是6,7,11,10，占据调整之后即可。所以，如果子矩阵的大小是M×M，一共就有M-1组，分别进行占据调整即可。
代码：
/**
* 将正方形矩阵顺时针旋转90°
*/
public class RotateMatrix {
public static void rotate(int[][] matrix) {
int tR = 0;
int tC = 0;
int dR = matrix.length - 1;
int dC = matrix[0].length - 1;
while (tR < dR) {
rotateEdge(matrix, tR++, tC++, dR--, dC--);
}
}
private static void rotateEdge(int[][] matrix, int tR, int tC, int dR, int dC) {
int times = dC - tC;//times就是总的组数
int temp = 0;
for (int i = 0; i != times; i++) {//一次循环就是一组占据调整
temp = matrix[tR][tC + i];
matrix[tR][tC + i] = matrix[dR - i][tC];
matrix[dR - i][tC] = matrix[dR][dC - i];
matrix[dR][dC - i] = matrix[tR - i][dC];
matrix[tR - i][dC] = temp;
}
}
}
题目六：“之”字形打印矩阵
题目：
给定一个矩阵matrix，按照“之”字形的方式打印矩阵，例如：
1 2 3 4
5 6 7 8
9 10 11 12
“之”字形打印的结果为：1,2,5,9,6,3,4,7,10,11,8,12
要求：
额外空间复杂度为O（1）
思路;
上坐标（tR,tC）初始化为（0,0）,先沿着矩阵第一行移动（tC++），当到达第一行最右边的元素后，在沿着矩阵最后一列移动（tR++）。
下坐标（dR,dC）初始为（0,0）,先沿着矩阵第一列移动（dR++），当到达第一列最下边的元素时，再沿着矩阵最后一行移动（dC++）。
上坐标与下坐标同步移动，每次移动后的上坐标与下坐标的连线就是矩阵中的一条斜线，打印斜线上的元素即可。
如果上次斜线是从左下向右上打印的，这次一定是从右上向左下打印，反之亦然。总之，可以把打印的方向用boolean值表示，每次取反即可。
代码：
/**
* 之字形打印矩阵
*/
public class PrintMatrixZigZag {
public static void printMatrixZigZag(int[][] matrix) {
int tR = 0;
int tC = 0;
int dR = 0;
int dC = 0;
int endRow = matrix.length - 1;
int endCol = matrix[0].length - 1;
boolean fromUp = false;
while (tR != endRow + 1) {
printLevel(matrix, tR, tC, dR, dC, fromUp);
tR = tC == endCol ? tR + 1 : tR;
tC = tC == endCol ? tC : tC + 1;
dR = dR == endRow ? dR : dR + 1;
dC = dR == endRow ? dC + 1 : dC;
fromUp = !fromUp;
}
System.out.println();
}
private static void printLevel(int[][] matrix, int tR, int tC, int dR, int dC, boolean fromUp) {
if (fromUp) {
while (tR != dR + 1) {//从左下到右上
System.out.print(matrix[tR++][tC--] + " ");
}
} else {
while (dR != tR - 1) {//从右上到左下
System.out.print(matrix[dR--][dC++] + " ");
}
}
}
}题目七
给定一个长度为N的整型数组arr，其中有N个互不相等的自然数1~N
请实现arr的排序
但是不要把下标0~N-1位置上的数值通过直接赋值的方式替换成1~N。
要求：时间复杂度为O(N)，额外空间复杂度为O(1)。
思路：从左向右检查，检查到需要换的以后，就直接把它放到该去的位置，然后被换掉的数，位置肯定也不对，继续重复相同的方法，最后肯定会跳回来（原因懒得说了自己想想），然后继续往下检查即可。
public static void sort1(int[] arr) {
int tmp = 0;
int next = 0;
for (int i = 0; i != arr.length; i++) {
tmp = arr[i];
while (arr[i] != i + 1) {
next = arr[tmp - 1];
arr[tmp - 1] = tmp;
tmp = next;
}
}
}题目八
本题一般思路：依次查找找到比前后都小的数；或者选出最小数，他肯定是局部最小的；等等
但这些都是O(n)的方法，而用二分可以做到O(logn).
二分思路：
考虑最左和最右的元素：如果arr[0]<arr[1] return 0; arr[N-1]<arr[N-2] return N-1;
考虑最中间元素，如果中间元素大于它左边的元素，那么局部最小值就应该在数组的左半部分
如果中间元素小于大于它右边的元素，那么局部最小值就应该在数组的右半部分
中间元素既小于它左边的值又小于它右边的值，那么它就是局部最小
题目九
给定一个整数数组arr，返回不包含本位置的累乘数组。
比如2 3 1 4返回12 8 24 6
方法一：算出所有数的乘积，每个位置除以自己即可。要注意坑：如果数组中有一个0，那么0这个位置就是其他数的乘积，其他位置全为0；如果有多个0，那么所有位置都是0.
public int[] product1(int[] arr) {
if(arr==null || arr.length<2) {
return null;
}
int count=0;//0的个数
int all=1;//除0以外的数的乘积
for(int i=0;i!=arr.length;i++) {
if(arr[i]!=0) {
all*=arr[i];
}else {
count++;
}
}
int[] res=new int[arr.length];
if(count==0) {
for(int i=0;i!=arr.length;i++) {
res[i]=all/res[i];
}
}else if(count==1) {
for(int i=0;i!=arr.length;i++) {
if(arr[i]==0) {
res[i]=all;
}
}
}
return res;
}题目十：子数组的最大累加和问题
输入一个整形数组，求数组中连续的子数组使其和最大。比如，数组x
应该返回 x[2..6]的和187.
这四个代码完成的功能都是求最大子数组（注意用词准确，子数组连续，子序列可以不连续）。
1）
for(i = 1; i <= n; i++)
scanf("%d", &num[i]);
ans = num[1];
for(i = 1; i <= n; i++)
{
for(j = i; j <= n; j++)
{
s = 0;
for(k = i; k <= j; k++)
s += num[k];
if(s > ans)
ans = s;
}
}分别枚举每一个子数组的起点和终点，也就是i和j，对于每一个起点和终点，对中间部分求和，也就是k循环。显然有n个起点n个终点（去重减半，不影响复杂度），所以子数组数量为O(N^2)，对于每个子数组，我们要遍历一下求和，子数组长度1-n不等，遍历一遍平均O(N)，乘起来O(N^3).（注意可能产生时间更大的错觉）。找出所有子数组中最大的即可。
2）
for(i = 1; i <= n; i++)
scanf("%d", &num[i]);
sum[0] = 0;
for(i = 1; i <= n; i++) {
sum[i] = num[i] + sum[i - 1];
}
ans = num[1];
for(i = 1; i <= n; i++) {
for(j = i; j <= n; j++) {
s = sum[j] - sum[i - 1];
if(s > ans) ans = s;
}
}预处理出每一个以第一个元素开始，第i个元素结尾的子数组和，还是枚举每个起点终点，但是我们求和时直接减就可以了，不用遍历。对于每个子数组，操作为O(1),子数组数量O(N^2),所以总时间O(N^2).
3）
int solve(int left, int right)
{
if(left == right)
return num[left];
mid = (left + right) / 2;
lans = solve(left, mid);
rans = solve(mid + 1, right);
sum = 0, lmax = num[mid], rmax = num[mid + 1];
for(i = mid; i >= left; i--) {
sum += num[i];
if(sum > lmax) lmax = sum;
}
sum = 0;
for(i = mid + 1; i <= right; i++) {
sum += num[i];
if(sum > rmax) rmax = sum;
}
ans = lmax + rmax;
if(lans > ans) ans = lans;
if(rans > ans) ans = rans;
return ans;
}
int main(void)
{
scanf("%d", &n);
for(i = 1; i <= n; i++)
scanf("%d", &num[i]);
printf("%d\n", solve(1, n));
return 0;
}二分，求左右两边最大子数组，取最大。但是还有一种情况：包含断点的那些子数组也要考虑，请思考那两个那两个循环为什么那么写？最后逻辑为何正确？
4）动态规划入门思想
没有枚举，num[i]的含义是以下标i结尾的所有子数组中最大的。
遍历数组，对于第i个元素，它的所有子数组下标范围有[1,i],[2,i].....[i-1,i],还有它自己，我们看i-1个元素，他的子数组为[1,i-1],[2,i-1].....[i-1]。请想num[i]的含义，我们求i结尾的，只要把i-1结尾的最大加上i就好了，当然如果i-1结尾最大子数组是负的，i结尾最大子数组就是它本身。
为什么O(N)？时间省在哪里了？我们省掉了许多没必要的计算，计算i时，之前的数组和已经都计算过，朴素算法并没有记录下来，而是重复计算，造成时间浪费。算法优化的过程就是去掉重复计算的过程。
for(i = 1; i <= n; i++)
scanf("%d", &num[i]);
num[0] = 0;
ans = num[1];
for(i = 1; i <= n; i++)
{
if(num[i - 1] > 0)
num[i] += num[i - 1];
else
num[i] += 0;
if(num[i] > ans)
ans = num[i];
}题目十一、子矩阵的最大累加和问题
给一个矩阵，请找出一个矩阵中，和最大的子矩阵。
如果大家看懂了上一题的讲解，我给个提示：利用第二个代码和第四个代码思想的结合
解释：
1 2 3 4
-1 -2 1 2
1 3 -2 1
-1 -2 -1 -3
如图是前三行整体最大
怎么做呢？
先用第二个代码的思想，我们进行预处理
每个数代表这一列到这个数位置截止，累加和。
1 2 3 4
0 0 4 6
1 3 2 7
0 1 1 4
然后，我们枚举每一列的起点和终点分别为第0，1，2，3行
然后压缩成一维来做
比如求1-3行的这个矩形，我们拿0和3行减一下就行了
0-1，1-2，1-3，4-4=-1，-1，-2，0就是1-3行压缩后的结果
然后按一维dp来做就好
public class SubMatrixMaxSum {
public static int maxSum(int[][] m) {
if (m == null || m.length == 0 || m[0].length == 0) {
return 0;
}
int max = Integer.MIN_VALUE;
int cur = 0;
int[] s = null; // 累加数组
for (int i = 0; i != m.length; i++) {
s = new int[m[0].length];
for (int j = i; j != m.length; j++) {
cur = 0;
for (int k = 0; k != s.length; k++) {
s[k] += m[j][k];
cur += s[k];
max = Math.max(max, cur);
cur = cur < 0 ? 0 : cur;
}
}
}
return max;
}
public static void main(String[] args) {
int[][] matrix = { { -90, 48, 78 }, { 64, -40, 64 }, { -81, -7, 66 } };
System.out.println(maxSum(matrix));
}
}
题目十二、子数组的最大累乘积
题目：
给定一个double类型的数组arr，其中的元素可正、可负、可为0。返回子数组累乘的最大乘积。
思路：
假设以arr[i-1]结尾的数组最小累乘积为min，最大累乘积为max，那么以arr[i]结尾的数组的最大累乘积可能有三种情况。
- max*arr[i]//本身乘之前的最大累乘
- min*arr[i]//可能是负负得正变成最大的
- arr[i]//可能就是它本身，比如之前的max小于1
public class SubArrayMaxProduct {
public static double maxProduct(double[] arr) {
if (arr == null || arr.length == 0) {
return 0;
}
double max = arr[0];
double min = arr[0];
double res = arr[0];
double maxEnd = 0;
double minEnd = 0;
for (int i = 1; i < arr.length; ++i) {
maxEnd = max * arr[i];
minEnd = min * arr[i];
max = Math.max(Math.max(maxEnd, minEnd), arr[i]);
min = Math.min(Math.min(maxEnd, minEnd), arr[i]);
res = Math.max(res, max);
}
return res;
}
public static void main(String[] args) {
double[] arr = { -2.5, 4, 0, 3, 0.5, 8, -1 };
System.out.println(maxProduct(arr));
}
}
题目十三：调整有序的arr数组，使得左半部分有序且不重复，不用保证右边是否有序。
思路：
u : 左边的最后位置，即0---u为答案
i : 从u到右遍历
当arr[i]和arr[u]不相等时，说明是目前遇到的最大的数，此时调换arr[u+1]和arr[i]
public static void leftUnique(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int u = 0;
int i = 1;
while (i != arr.length) {
if (arr[i++] != arr[u]) {
swap(arr, ++u, i - 1);
}
}
} public static void swap(int[] arr, int index1, int index2) {
int tmp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = tmp;
}题目十四：数组arr中只有三种值：0，1，2，请排序
思路：荷兰国旗问题：https://blog.csdn.net/hebtu666/article/details/81772701
上面的网址介绍了思路和c++实现，本文给出java实现。
public static void sort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
int left = -1;
int index = 0;
int right = arr.length;
while (index < right) {
if (arr[index] == 0) {
swap(arr, ++left, index++);
} else if (arr[index] == 2) {
swap(arr, index, --right);
} else {
index++;
}
}
}题目十五：数组arr，给定k，请实现比k小的放左边，等于k的放中间，大于k的放右边
同样的分三区，只是条件改一下，<k,=k,>k即可。