算法：谈谈数据结构【数组】那些事

最新推荐文章于 2024-07-10 21:00:00 发布

北斗星_And

最新推荐文章于 2024-07-10 21:00:00 发布

阅读量303

点赞数 1

CC 4.0 BY-SA版权

分类专栏：算法

本文链接：https://blog.youkuaiyun.com/dingdegao/article/details/99410360

算法专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨数组算法，从暴力解法到动态规划优化，涵盖最大子序列求和、组合求和及爬楼梯等经典问题，解析一维与二维数组应用技巧。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

导读: 数据是最基本的数据结构，能解决很多问题，比如常见的 $C_n^m$ , $A_n^m$ 求解,使用数组来解决重复递归过程，动态规划使用数组记录最近解过程中的各个步骤的解。今天我们用几个常见的面试题来谈一谈算法——数据结构【数组】那些事

背景

数组是最常见的也是经常使用的数据结构,大多数语言的封装类型（List/Map）都含有数组的身影。我们知道数组时一块连续的内存区域，访问某个数据时用数组下标访问，当扩容和删除时略显麻烦.

那我们怎么才能用好数组呢？怎么能快速使用数组这种简单的数据结构来解决复杂的问题呢？

下面我们从一到题来引入讲解数组解一些常见的算法题.

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例: 输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

最大子序列求和的解法

在我的思维里，如果一个问题，你之前没做过，没有系统的学习过此类通用算法解决，那么暴力就是能想到的第一种解法思路。

下面我们来看一下暴力解题法，怎么去做？首先我们可以想到

列举数组中的所有可能的连续区间/子集？然后把连续区间相加，求和，判断最大.

解法一：时间复杂度 $O(n^3)$

    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;
    }

解法二：时间复杂度 $O(n^2)$

其实我们在列举的过程中就可以把和相加起来，进行判断，所有有了解法二

    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;
    }

解法三：动态规划时间复杂度 $O (n)$

看了上述的暴力解题法，我们发现一些可以优化的东西，因为他有重复的子结构性质，那就是每次相加都从开始的那个元素去相加，那我们可以从动态规划的角度想一下这个问题。

设sum[i]为以第i个元素结尾且和最大的连续子数组，那我们可以把上述问题描述为这样的一个公式
$s u m [i] = m a x (s u m [i - 1] + n u m s [i], n u m s [i])$
把公式化解一下就是这样的.
$sum[i]=\begin{cases} nums[i] & if(sum[i-1] <= 0) \\ sum[i-1] + nums[i] & if(sum[i-1]> 0) \end{cases}$
那么算法可以描述为

  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;
    }

这样算法的空间复杂度为 $O (n)$ ，如果原数据数组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循环求解 $C_n^m$

$A_n^m$ 排列问题和组合问题很相似（经典问题有全排列）,这里列举一道 $C_n^m$ 相关的题

给定一个无重复元素的数组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循环求解 $C_n^m$ .
这可以解决很多与组合相关的问题，如密码暴力破解等.

给你一个字符串，列举里面所有可能的三位密码，（字符串里面字母都不相同，不考虑密码顺序）

这样我们能很简单的想到一个算法

    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 个台阶。你有多少种不同的方法可以爬到楼顶呢？

如果你之前见过这题，那应该知道这是一个斐波那契数列（相似的问题还有很多，如兔子繁殖问题等都是斐波那契数列），可以描述为
$f (n) = f (n - 1) + f (n - 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”）。
问总共有多少条不同的路径？

有了上面的暴力解题思路过程，并且此题也有一些重叠子问题，那我们这题，直接考虑动态规划解决. 可以想到递归函数为

$sum[i][j]=\begin{cases} 1 & if(i == 0 || j == 0) \\ sum[i-1][j] + sum[i][j-1] & if(i > 0 \&\& j > 0) \end{cases}$

根据递归公式代码，也能轻松写出

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];
    }
}