一文搞懂数组，上机考试再也不会慌

祖母绿宝石

已于 2022-11-30 20:41:31 修改

阅读量384

点赞数

分类专栏：算法专区文章标签：算法面试

于 2021-03-05 21:45:36 首次发布

本文链接：https://blog.csdn.net/qq_36963950/article/details/114415700

版权

算法专区专栏收录该内容

7 篇文章 1 订阅

订阅专栏

文章目录

一、前言
二、有序数组的二分查找
三、双指针滑动窗口算法
- 3.1 暴力解法
- 3.2 滑动窗口
四、二维数组做矩阵
五、尾声

一、前言

一文搞懂回溯算法，上机考试再也不会慌

二、有序数组的二分查找

关于数组二分查找，核心注意几点：
使用条件：有序数组，且无重复元素
如果找不到，会出现[right,left]的情况，即right在前，left在后，最后返回return right+1;是正确的
能够处理四种情况就是一个合格的二分查找
1、目标值在数组所有元素之前
2、目标值等于数组中某一个元素
3、目标值插入数组中的位置
4、目标值在数组所有元素之后

2.1 题目

题目链接：35. 搜索插入位置

这道题目，要在数组中插入目标值，无非是这四种情况。

目标值在数组所有元素之前
目标值等于数组中某一个元素
目标值插入数组中的位置
目标值在数组所有元素之后

这四种情况确认清楚了，就可以尝试解题了。

接下来我将从暴力的解法和二分法来讲解此题，也借此好好讲一讲二分查找法。

2.2 暴力解法

暴力解题不一定时间消耗就非常高，关键看实现的方式，就像是二分查找时间消耗不一定就很低，是一样的。

暴力解法C++代码

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        for (int i = 0; i < nums.size(); i++) {
        // 分别处理如下三种情况
        // 目标值在数组所有元素之前
        // 目标值等于数组中某一个元素  
        // 目标值插入数组中的位置 
            if (nums[i] >= target) { // 一旦发现大于或者等于target的num[i]，那么i就是我们要的结果
                return i;
            }
        }
        // 目标值在数组所有元素之后的情况 
        return nums.size(); // 如果target是最大的，或者 nums为空，则返回nums的长度
    }
};

时间复杂度：O(n)
空间复杂度：O(1)

2.3 二分法

既然暴力解法的时间复杂度是O(n)，就要尝试一下使用二分查找法。

大家注意这道题目的前提是数组是有序数组，这也是使用二分查找的基础条件。

以后大家「只要看到面试题里给出的数组是有序数组，都可以想一想是否可以使用二分法。」

同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下表可能不是唯一的。

大体讲解一下二分法的思路，这里来举一个例子，例如在这个数组中，使用二分法寻找元素为5的位置，并返回其下标。

二分查找涉及的很多的边界条件，逻辑比较简单，就是写不好。

相信很多同学对二分查找法中边界条件处理不好。

例如到底是 while(left < right) 还是 while(left <= right)，到底是right = middle呢，还是要right = middle - 1呢？

这里弄不清楚主要是因为「对区间的定义没有想清楚，这就是不变量」。

要在二分查找的过程中，保持不变量，这也就是「循环不变量」（感兴趣的同学可以查一查）。

2.3.1 二分法第一种写法

以这道题目来举例，以下的代码中定义 target 是在一个在左闭右闭的区间里，「也就是[left, right] （这个很重要）」。

这就决定了这个二分法的代码如何去写，大家看如下代码：

「大家要仔细看注释，思考为什么要写while(left <= right)，为什么要写right = middle - 1」。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0;
        int right = n - 1; // 定义target在左闭右闭的区间里，[left, right] 
        while (left <= right) { // 当left==right，区间[left, right]依然有效
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle;
            }
        }
        // 分别处理如下四种情况
        // 目标值在数组所有元素之前  [0, -1]
        // 目标值等于数组中某一个元素  return middle;
        // 目标值插入数组中的位置 [left, right]，最后会出现[right,left]的情况，所以return  right + 1
        // 目标值在数组所有元素之后的情况 [left, right]， return right + 1
        return right + 1;
    }
};

时间复杂度：O(logn)
空间复杂度：O(1)

看一个Java版本的，如下：

class Solution {
    public int searchInsert(int[] nums, int target) {
      int left=0;
      int right=nums.length-1;
      while(left<=right){
          int middle = (left+right)/2;
          if(nums[middle]>target)
              right=middle-1;
          else if(nums[middle]<target)
              left=middle+1;
          else
             return middle;
      }
      return right+1;
    }
}

可以将/2变成>>1，如下：

class Solution {
    public int searchInsert(int[] nums, int target) {
      int left=0;
      int right=nums.length-1;
      while(left<=right){
          int middle = (left+right)>>1;
          if(nums[middle]>target)
              right=middle-1;
          else if(nums[middle]<target)
              left=middle+1;
          else
             return middle;
      }
      return right+1;
    }
}

2.3.2 二分法第二种写法（了解即可）

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) 。

那么二分法的边界处理方式则截然不同。

不变量是[left, right)的区间，如下代码可以看出是如何在循环中坚持不变量的。

「大家要仔细看注释，思考为什么要写while (left < right)，为什么要写right = middle」。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0;
        int right = n; // 定义target在左闭右开的区间里，[left, right)  target
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在 [middle+1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值的情况，直接返回下标
            }
        }
        // 分别处理如下四种情况
        // 目标值在数组所有元素之前 [0,0)
        // 目标值等于数组中某一个元素 return middle
        // 目标值插入数组中的位置 [left, right) ，return right 即可
        // 目标值在数组所有元素之后的情况 [left, right)，return right 即可
        return right;
    }
};

时间复杂度：O(logn)
空间复杂度：O(1)

2.4 总结

二分法适用性：仅用于有序数组，且数组中无重复元素；

二分法题目：在这样的一个数组根据给定值查找元素；

二分法技巧：

(1) 区间定义搞清楚：确定要查找的区间到底是左闭右开[left, right)，还是左闭又闭[left, right]，这就是不变量；
(2) 然后在二分查找的循环中，坚持循环不变量的原则。

三、双指针滑动窗口算法

题目链接：209. 长度最小的子数组

3.1 暴力解法

这道题目暴力解法当然是两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2) 。

代码如下：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
       int result = Integer.MAX_VALUE;
       int sum=0;
       for (int slowIndex=0;slowIndex<nums.length;slowIndex++){
           sum=0;
           for (int fastIndex = slowIndex;fastIndex<nums.length;fastIndex++){
               sum = sum + nums[fastIndex];
              if(sum >= target){
                 int sublength = fastIndex-slowIndex+1;   
                 result = Math.min(result,sublength);
                 break;
               }
           }
       }
       return result == Integer.MAX_VALUE ? 0 : result;
    }
}

时间复杂度：O(n^2)
空间复杂度：O(1)

3.2 滑动窗口

接下来就开始介绍数组操作中另一个重要的方法：「滑动窗口」。

所谓滑动窗口，「就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果」。

这里还是以题目中的示例来举例，s=7，数组是 2，3，1，2，4，3，来看一下查找的过程：

图片

最后找到 4，3 是最短距离。

其实从动画中可以发现滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，所以叫做滑动窗口更适合一些。

在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？
如何移动窗口的起始位置？
如何移动窗口的结束位置？
窗口就是满足其和 ≥ s 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了。

解题的关键在于窗口的起始位置如何移动，如图所示：

图片

可以发现「滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。」

Java版本代码

public class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE;
        int sum = 0;
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
            sum = sum + nums[fastIndex];
            while (sum >= target) {
                int sublength = fastIndex - slowIndex + 1;
                result = Math.min(result, sublength);
                sum = sum - nums[slowIndex];
                slowIndex++;
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

四、二维数组做矩阵

59. 螺旋矩阵 II

本题并不涉及到什么算法，就是模拟过程，要如何画出这个螺旋排列的正方形矩阵呢？

模拟顺时针画矩阵的过程:

填充上行从左到右
填充右列从上到下
填充下行从右到左
填充左列从下到上

由外向内一圈一圈这么画下去。

可以发现这里的边界条件非常多，在一个循环中，如此多的边界条件，如果不按照固定规则来遍历，那就是「一进循环深似海，从此offer是路人」。

这里一圈下来，我们要画每四条边，这四条边怎么画，每画一条边都要坚持一致的左闭右开，或者左开又闭的原则，这样这一圈才能按照统一的规则画下来。

那么我按照左闭右开的原则，来画一圈，大家看一下：

这里每一种颜色，代表一条边，我们遍历的长度，可以看出每一个拐角处的处理规则，拐角处让给新的一条边来继续画。

这也是坚持了每条边左闭右开的原则。

一些同学做这道题目之所以一直写不好，代码越写越乱。

就是因为在画每一条边的时候，一会左开又闭，一会左闭右闭，一会又来左闭右开，岂能不乱。

代码如下，已经详细注释了每一步的目的，可以看出while循环里判断的情况是很多的，代码里处理的原则也是统一的左闭右开。

public class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];   // 二维数组
        int count = 1;   // 用来给矩阵中每一个空格赋值
        int offset = 1;  // 每一圈循环，需要控制每一条边遍历的长度
        int loopCount = n / 2;  // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2;   // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int startX = 0;   // 定义每循环一个圈的起始位置
        int startY = 0;
        int i = 0;
        int j = 0;
        while (loopCount > 0) {
            for (j = startY; j < startY + n - offset; j++) {
                res[startX][j] = count;
                count++;
            }

            for (i = startX; i < startX + n - offset; i++) {
                res[i][j] = count;
                count++;
            }

            for (; j > startY; j--) {
                res[i][j] = count;
                count++;
            }

            for (; i > startX; i--) {
                res[i][j] = count;
                count++;
            }
            
            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startX++;
            startY++;
            offset = offset + 2;               // offset 控制每一圈里每一条边遍历的长度
            loopCount--;
        }
        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2 == 1) {
            res[mid][mid] = count;
        }
        return res;
    }
}

也可以让int count=0，只是先count++，然后设置res数组的值，最后设置奇数列也是这样

public class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res = new int[n][n];   // 二维数组
        int count = 0;   // 用来给矩阵中每一个空格赋值
        int offset = 1;  // 每一圈循环，需要控制每一条边遍历的长度
        int loopCount = n / 2;  // 每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
        int mid = n / 2;   // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
        int startX = 0;   // 定义每循环一个圈的起始位置
        int startY = 0;
        int i = 0;
        int j = 0;
        while (loopCount > 0) {
            
            for (j = startY; j < startY + n - offset; j++) {
                count++;
                res[startX][j] = count;  // 第一个不用i，用startX，其他三个都是用i
            }

            for (i = startX; i < startX + n - offset; i++) {
                count++;
                res[i][j] = count;
            }

            for (; j > startY; j--) {
                count++;
                res[i][j] = count;
            }

            for (; i > startX; i--) {
                count++;

                res[i][j] = count;
            }

            // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
            startX++;
            startY++;
            offset = offset + 2;               // offset 控制每一圈里每一条边遍历的长度
            loopCount--;
        }
        // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
        if (n % 2 == 1) {
            count++;
            res[mid][mid] = count;
        }
        return res;
    }
}