数据结构与算法1.数组

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

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

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的
  数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

二维数组的空间是连续的吗？
不同编程语言的内存管理是不一样的，以C++为例，在C++中二维数组是连续分布的。
Java是没有指针的，同时也不对程序员暴露其元素的地址，寻址操作完全交给虚拟机。所以看不到每个元素的地址情况。

Java中方法：

• 数组大小： 名字.length
• 排序：
  • 升序排序： Arrays.sort(名字)
• 最大数值 Integer.MAX_VALUE

1 二分查找法

二分查找法的前提：

1. 数组为有序数组
2. 数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的
   二分查找法涉及到边界问题。要在二分查找的过程中，保持不变量，就是在while寻找中每一次边界的处理都要坚持根据区间的定义来操作，这就是循环不变量规则。
   写二分法，区间的定义一般为两种，左闭右闭即[left, right]，或者左闭右开即[left, right)。

题目：https://leetcode.cn/problems/binary-search/
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
左闭右闭即[left, right]：
区间的定义这就决定了二分法的代码应该如何写，因为定义target在[left, right]区间，所以有如下两点：

• while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
• if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

class Solution {
    public int search(int[] nums, int target) {

        if (target < nums[0] || target > nums[nums.length - 1])
            return -1;
        
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + ((right - left) >> 1);
            if (nums[mid] == target) return mid;
            else if (nums[mid] < target) left = mid + 1;
            else if (nums[mid] > target) right = mid - 1;
        }

        return -1;

    }
}

左闭右开即[left, right)：
有如下两点：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

2 双指针法

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。
题目：移除元素https://leetcode.cn/problems/remove-element/
给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

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

3 滑动窗口

https://leetcode.cn/problems/minimum-size-subarray-sum/
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
示例：
输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。
滑动窗口也可以理解为双指针的一种
只用一个for循环的话，那么这个循环的索引，一定是表示滑动窗口的终止位置

• 窗口就是 满足其和 ≥ s 的长度最小的 连续 子数组。
• 窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。
• 窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;

        for (int right = 0; right < nums.length; right ++) {
            sum += nums[right];
            
            while (sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;

    }
}

4 二维数组（螺旋矩阵）

59. 螺旋矩阵 II - 力扣（LeetCode）
    给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
    示例:
    输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
    在任何一个循环过程中，都得按照固定的规律来。这里一圈下来，我们要画每四条边，这四条边怎么画，每画一条边都要坚持一致的左闭右开，或者左开右闭的原则，这样这一圈才能按照统一的规则画下来。

class Solution {
    public int[][] generateMatrix(int n) {
        //vector

        int[][] res = new int[n][n];
        int i, j;
        int count = 1; //用来给每一个空格赋值
        int loop = 0; //控制循环次数
        int start = 0;  //每一圈的起始位置
        

        //n为奇数的时候，中心的值单独赋值
        if (n % 2 == 1) {
            res[n / 2][n / 2] = n * n;
        }

        //开始绕圈循环
        while (loop++ < n / 2) {
            
            //四个for循环即旋转一圈
            //左闭右开

            //上
            for (j = start; j < n - loop; j ++) {
                res[start][j] = count++;
            }

            //右
            for (i = start; i < n - loop; i ++) {
                res[i][j] = count++;
            }

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

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

            start++;

        }
        return res;
    }
}