超硬核!躺进BAT以后我总结了出现最多的15道数组题

作为一个硬核作者,绝不和你扯废话,干货无套路送你

题目一:

    给定一个数组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即可。

 

兔兔RabbitMQ!!! CSDN认证博客专家 Go/GoLang Redis MySQL
全站最硬核博主(之一)。在腾讯总部工作,bat/tmd有五家发过offer。acm/leetcode刷题狂,c /Java/python/go/php各种后端语言都喜欢,安卓/node/叶子/jsp等前端也能写,最喜欢鼓捣各种组件,请多指教。
已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页