leetcode系列-数组

数组理论基础

数组是存放在连续内存空间上的相同类型数据的集合。

数组可以方便的通过下标索引的方式获取到下标下对应的数据。

举一个字符数组的例子，如图所示：

 

需要两点注意的是

• 数组下标都是从0开始的。

• 数组内存空间的地址是连续的

正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

例如删除下标为3的元素，需要对下标为3的元素后面的所有元素都要做移动操作，如图所示：

 

而且大家如果使用C++的话，要注意vector 和 array的区别，vector的底层实现是array，严格来讲vector是容器，不是数组。

数组的元素是不能删的，只能覆盖。

那么二维数组直接上图，大家应该就知道怎么回事了

 

那么二维数组在内存的空间地址是连续的么？

我们来举一个例子，例如： int[][] rating = new int[3][4]; ， 这个二维数据在内存空间可不是一个 3*4 的连续地址空间

看了下图，就应该明白了：

 

所以二维数据在内存中不是 3*4 的连续地址空间，而是四条连续的地址空间组成！

 

二分法时间复杂度：

查找数据长度为N，每次查找后减半，

第一次 N/2

...

第k次 N/2^k

最坏的情况下第k次才找到，此时只剩一个数据，长度为1。

即 N/2^k = 1

查找次数 k=log(N)。

 

数组的经典题目

二分法

35-给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

    /**
     * 二分法，注意边界条件
     */
class Solution {
​
    public int searchInsert(int[] nums, int target) {
​
        int left = 0;
​
        int rigth = nums.length;
​
        while(left < rigth){
            int mid=(left + rigth) / 2;
            if(nums[mid] >= target) {
                rigth = mid;
            } else{
                left = mid+1;
            }
        }
        return left;
    }
}

复杂度分析

时间复杂度：O(logn)，其中 n 为数组的长度。二分查找所需的时间复杂度为 O(logn)。

空间复杂度：O(1)。我们只需要常数空间存放若干变量。

 

双指针法

27- 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

class Solution {
    public int removeElement(int[] nums, int val) {
        int i = 0;
        for (int j = 0; j <nums.length ; j++) {
            if (nums[j] != val){
                nums[i] = nums[j];
                i++;
            }
        }
        return i;
    }
}

复杂度分析

• 时间复杂度：O(n) 假设数组总共有 n个元素，i 和 j至少遍历 2n步。

• 空间复杂度：O(1)

 

滑动窗口

• 数组：滑动窗口拯救了你

209-给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

/**
 * 滑动窗口
 * 所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果
 *
 * 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
 * 窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
 * 窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了
 * 滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)的暴力解法降为O(n)。
 */
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
​
        int n = nums.length;
        if (n == 0){
            return 0;
        }
​
        int ans = Integer.MAX_VALUE;
        int start = 0,end = 0;
        int sum = 0;
        while (end < n){
            sum+= nums[end];
            while (sum >= target){
                ans = Math.min(ans,end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return ans == Integer.MAX_VALUE ? 0 : ans;
​
    }
}

复杂度分析

时间复杂度：O(n^2)，其中 n是数组的长度。需要遍历每个下标作为子数组的开始下标，对于每个开始下标，需要遍历其后面的下标得到长度最小的子数组。

空间复杂度：O(1)

 

模拟行为

59-给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

**
 * 从左到右填入上侧元素，依次为(up,left) 到 (up,right)。
 * 从上到下填入右侧元素，依次为 (up+1,right) 到 (down,right)。
 * 如果 left<right 且 up<down，则从右到左填入下侧元素，依次为 (down,right−1) 到 (down,left+1)
 * 从下到上填入左侧元素，依次为 (down,left)到 (up+1,left)。
 *填完当前层的元素之后，将 left 和 up 分别增加 1，将 right 和 down 分别减少 1，进入下一层继续填入元素，直到填完所有元素为止。
 *
 *
 */
class Solution {
    public int[][] generateMatrix(int n) {
​
        int[][] res = new int[n][n];
        int up = 0, down = n - 1, left = 0, right = n - 1, index = 1;
        while(index <= n * n){
            for(int i = left; i <= right; i++){
                res[up][i] = index++;
            }
            up++;
            for(int i = up; i <= down; i++){
                res[i][right] = index++;
            }
            right--;
            for(int i = right; i >= left; i--){
                res[down][i] = index++;
            }
            down--;
            for(int i = down; i >= up; i--){
                res[i][left] = index++;
            }
            left++;
        }
        return res;
​
    }
}

复杂度分析

时间复杂度：O(n^2)，其中 n 是给定的正整数。矩阵的大小是 n×n，需要填入矩阵中的每个元素。

空间复杂度：O(1)。除了返回的矩阵以外，空间复杂度是常数。