导读: 数据是最基本的数据结构，能解决很多问题，比如常见的,
求解,使用数组来解决重复递归过程，动态规划使用数组记录最近解过程中的各个步骤的解。今天我们用几个常见的面试题来谈一谈算法——数据结构【数组】那些事
背景
数组是最常见的也是经常使用的数据结构,大多数语言的封装类型（List/Map）都含有数组的身影。我们知道数组时一块连续的内存区域，访问某个数据时用数组下标访问，当扩容和删除时略显麻烦.
那我们怎么才能用好数组呢？怎么能快速使用数组这种简单的数据结构来解决复杂的问题呢？
下面我们从一到题来引入讲解数组解一些常见的算法题.
给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
示例: 输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
最大子序列求和的解法
在我的思维里，如果一个问题，你之前没做过，没有系统的学习过此类通用算法解决，那么暴力就是能想到的第一种解法思路。
下面我们来看一下暴力解题法，怎么去做？首先我们可以想到
列举 数组中的所有可能的连续区间/子集？然后把连续区间相加，求和，判断最大.
解法一： 时间复杂度 )
public int maxSubArray(int[] nums) {
int max = Integer.MIN_VALUE;
int sum;
//使用两个for循环来列举出所有的连续区间/子集
for (int i = 0; i < nums.length; i++) {
for (int j = i; j < nums.length; j++) {
sum = 0;
//列举出来的子集，在通过一个for循环相加
for (int k = i; k <= j; k++) {
sum += nums[k];
}
if (sum > max) {
max = sum;
}
}
}
return max;
}
解法二： 时间复杂度 )
其实我们在列举的过程中就可以把和相加起来，进行判断，所有有了解法二
public int maxSubArray(int[] nums) {
int max = Integer.MIN_VALUE;
int sum;
for (int i = 0; i < nums.length; i++) {
sum = 0;
for (int j = i; j < nums.length; j++) {
//列举子序列求和的过程中解决此问题
sum += nums[j];
if (sum > max)
max = sum;
}
}
return max;
}
解法三：动态规划 时间复杂度)
看了上述的暴力解题法，我们发现一些可以优化的东西，因为他有重复的子结构性质，那就是每次相加都从开始的那个元素去相加，那我们可以从动态规划的角度想一下这个问题。
设sum[i]为以第i个元素结尾且和最大的连续子数组，那我们可以把上述问题描述为这样的一个公式
把公式化解一下就是这样的.
那么算法可以描述为
public int maxSubArray(int[] nums) {
int sums[] = new int[nums.length];
sums[0] = nums[0];
int max = nums[0];
for (int i = 1; i < nums.length; i++) {
if (sums[i-1] > 0) sums[i] += nums[i];
else sums[i] = nums[i];
if (max < sums[i]) max = sums[i];
}
return max;
}
这样算法的空间复杂度为，如果原数据数组nums可以被更改，那么我们的sums数组可以省略.
public int maxSubArray(int[] nums) {
int currnetValue = nums[0];
int max = nums[0];
for (int i = 1; i < nums.length; i++) {
if (currnetValue > 0) currnetValue += nums[i];
else currnetValue = nums[i];
if (max < currnetValue) max = currnetValue;
}
return max;
}
n层for循环求解 
排列问题和组合问题很相似（经典问题有全排列）,这里列举一道
相关的题
给定一个无重复元素的数组candidates和一个目标数target，找出candidates中所有可以使数字和为target的组合。
candidates中的数字可以无限制重复被选取。
说明：
所有数字（包括target）都是正整数。
解集不能包含重复的组合。
示例1: 输入: candidates = [2,3,6,7], target = 7, 所求解集为:
[
[7],
[2,2,3]
]示例2:
输入: candidates = [2,3,5], target = 8,
所求解集为:
[
[2,2,2,2],
[2,3,3],
[3,5]
]
解法
按我的思路来，第一就去想暴力解法，然后再去想办法优化（如果你之前做过这题，或者直接能想到什么动态规划算法，可以直接使用，不要在暴力。）
想讲一个暴力通用解法模型，就是本节所说的n层for循环求解 .
这可以解决很多与组合相关的问题，如密码暴力破解等.
给你一个字符串，列举里面所有可能的三位密码，（字符串里面字母都不相同，不考虑密码顺序）
这样我们能很简单的想到一个算法
int len = str.length();
for(int i = 0;i < len - 2;i++){
for(int j = i +1;j<len - 1;j++){
for(int k = j+1;k<len;k++){
String password = ""+ str.charAt(i) + str.charAt(j) + str.charAt(k);
}
}
}
那要是现在列举100位密码呢？不可能写这样的循环了吧?
一般解法，是使用递归来替代n层for循环，一般解法模型,伪代码如下
void find(int start,int count,int passwordLen,int array[]){
if(count == passwordLen){
//得到结果
return;
}
for(int i = start;i<array.length;i++){
find(i + 1,count+1,passwordLen,array);
}
}
那么上面那道题，使用这个模型来解决代码如下:
class Solution {
public List<List<Integer>> combinationSum(int[] candidates, int target) {
List<List<Integer>> listAll = new ArrayList<>();
List<Integer> currentList = new ArrayList<>();
Arrays.sort(candidates);
find(listAll,currentList,candidates,target,0);
return listAll;
}
private void find(List<List<Integer>> listAll,List<Integer> currentList,int[] candidates,int target,int currentIndex) {
if(target < 0) return;
if(target == 0){
listAll.add(currentList);
}else{
for(int i = currentIndex;i<candidates.length && candidates[i]<=target;i++){
List<Integer> list=new ArrayList<>(currentList);
list.add(candidates[i]);
find(listAll,list,candidates,target - candidates[i],i);
//currentList.remove(currentList.size()-1);
}
}
}
}
爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
如果你之前见过这题，那应该知道这是一个斐波那契数列（相似的问题还有很多，如兔子繁殖问题等都是斐波那契数列），可以描述为
那么求这个公式怎么解呢？我们可以想到一个递归过程，如下
public int fib(int n) {
if(n <= 2) return 1;
else{
return fib(n-1) + fib(n-2);
}
}
我们知道递归过程中会有很多重复计算，这里列举一张法f(5）的计算过程，如下
那我们怎么解决这个问题呢，使用一个数组来保存结果，避免重复计算,(也被成为备忘录法则)，这里其实已经是动态规划了。
public int fib(int n) {
if(n <= 2) return 1;
if(save[n] > 0){
return save[n];
}else{
save[n] = save[n-1]+save[n-2];
return save[n];
}
}
我们知道递归有一个函数栈的调用过程，那我们可以尝试把递归去了
public int fib(int n) {
save[0] = 1;
save[1] = 1;
for(int i = 2;i < n;i++){
save[i] = save[i-1]+ save[i-2];
}
return save[n-1];
}
}
其实这个如果只是一次计算f(n)的结果，不用使用数组，可以优化为
int v1 = 1,v2=1;
for(int i = 2;i < n;i++){
int temp = v1 + v2;
v1 = v2;
v2 = temp;
}
return v2;
}
拓展：看完上述内容，你应该能轻松解决，如果楼梯不是一次只能上1或者2层，他能上任意层，怎么解决这个问题呢？欢迎留言区评论
关于二维数组
二维数组是在一维数组的基础上，增加了纵向。那二维数组一般的暴力解法和一维数组基本类似。常见的二维数组经典题目有 【n皇后问题】【走迷宫】 对应的回溯算法，也是暴力算法的一种，有一个剪枝，优化过程。 在这里举一个二维数组例子。
一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。
问总共有多少条不同的路径？
有了上面的暴力解题思路过程，并且此题也有一些重叠子问题，那我们这题，直接考虑动态规划解决. 可以想到递归函数为
根据递归公式代码，也能轻松写出
class Solution {
public int uniquePaths(int m, int n) {
int sum[][] = new int[m][n];
for(int i = 0;i<m;i++){
sum[i][0] = 1;
}
for(int i = 0;i<n;i++){
sum[0][i] = 1;
}
for(int i = 1;i<m;i++){
for(int j = 1;j<n;j++){
sum[i][j] = sum[i-1][j] + sum[i][j-1];
}
}
return sum[m-1][n-1];
}
}
总结
本文主要介绍了一些数组的算法，一些解题思路，从问题的暴力解法开始（通用的暴力解法：两个for循环列举，n层for循环等)，逐步优化，一些能想到的优化方式，节省空间，时间。到后面一些可以用动态规划解决的问题，（此处没有列举一些回溯常见解法，但是思路都是从暴力解法开始，逐步剪枝，优化的过程）
文末
因为本人技术有限，文中如有错误之处，还请大佬指教，感谢.
文中题目来源 LeetCode
如果你正在准备面试，或者你喜欢算法，刷题推荐LeetCode，挺不错的网站.
