【无标题】

---

1.数组理论基础

1.1数组概念

• 数组在java中是一种引用数据类型（不是基本数据类型）,父类为Object
• 数组是一个容器，可以储存相同类型的数据: 基本数据类型和引用数据类型
• 数组的存储位置在JVM（java虚拟机）内存划分中的堆内存中，用new来创建的内存空间，是一串连续的内存地址。每一个元素类型相同，因此占用内存空间大小一样。由于很难在内存空间上找到连续的特大空间，因此数组无法存储大量数据。
• 元素查询/检索方便，每个元素效率相同。随机删除/添加元素时效率较低。

1.2数组的初始化

静态初始化（指定内容，长度等于内容个数）

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};

    int[] arr = new int[]{1,2,3};
    // 可以拆分 
    int[] arr;
    arr = new int[]{1,2,3};

动态初始化（指定长度，默认初始值由数组的字符类型而定）

数组存储的数据类型[ ] 数组名字 = new 数组存储的数据类型[数组长度];
数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];

    int[] arr = new int[3];
    int   arr[] = new int[3];
    // 可以拆分 
    int[] arr;
    arr = new int[3];

1.3数组常用API

• Arrays.toString()
• Arrays.asList()
• List转数组 toArray()

2.leetcode704 二分查找

二分查找
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

提示：

你可以假设 nums 中的所有元素是不重复的。
n 将在 [1, 10000]之间。
nums 的每个元素都将在 [-9999, 9999]之间。

二分法区间问题

二分法最重要的两个点：

1. while循环中 left 和 right 的关系，到底是 left <= right 还是 left < right
2. 迭代过程中 middle 和 right 的关系，到底是 right = middle - 1 还是 right = middle

左闭右闭区间

第一种写法：每次查找的区间在[left, right]（左闭右闭区间），根据查找区间的定义（左闭右闭区间），就决定了后续的代码应该怎么写才能对。因为定义 target 在[left, right]区间，所以有如下两点：

1. 循环条件要使用while(left <= right)，因为当(left == right)这种情况发生的时候，得到的结果是有意义的
2. if(nums[middle] > target) ， right 要赋值为 middle - 1， 因为当前的 nums[middle] 一定不是 target ，需要把这个 middle 位置上面的数字丢弃，那么接下来需要查找范围就是[left, middle - 1]

int search(int nums[], int size, int target) //nums是数组，size是数组的大小，target是需要查找的值
{
    int left = 0;
    int right = size - 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 {	//既不在左边，也不在右边，那就是找到答案了
            return middle;
        }
    }
    //没有找到目标值
    return -1;
}

左开右闭区间

第二种写法：每次查找的区间在 [left, right)，（左闭右开区间）， 根据区间的定义，条件控制应该如下：

1. 循环条件使用while (left < right)
2. if (nums[middle] > target)， right = middle，因为当前的 nums[middle] 是大于 target 的，不符合条件,不能取到 middle，并且区间的定义是 [left, right)，刚好区间上的定义就取不到 right, 所以 right 赋值为 middle。

int search(int nums[], int size, int target)
{
	int left = 0;
	int right = size; //定义target在左闭右开的区间里，即[left, right)
	while (left < right) {	//因为left = right的时候，在[left, right)区间上无意义
		int middle = left + ((right - left) / 2);
		if (nums[middle] > target) {
			right = middle; //target 在左区间，在[left, middle)中 
		} else if (nums[middle] < target) {
			left = middle + 1;
		} else {
			return middle;
		}
	} 
    // 没找到就返回-1
	return -1;
}

总结: 二分法最重要的两个点，就是循环条件和后续的区间赋值问题
因为两者是相互联系，相互影响的，所以就需要两者统一，如果两者不统一，就会出现问题
所以循环条件和赋值问题必须统一，也就是循环不变量

3.leetcode27 移除元素

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

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

这道题的第一想法就是使用两个指针来做，大家叫一下这种用法为快慢指针。一个指针在后边等待处理，一个指针在前面寻找可以用来处理的数据。当然，快慢指针也还可以有其他走法，比如一个指针走一步，另一个指针走两步这样子。

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