D1 数组问题：leetcode704 二分查找与27移除元素举例

简述：数组是存放在连续内存空间上的相同类型数据的集合。但是对于二维数组C++与Java有着明显差异，C++的二维数组也是一块连续的内存，但是Java中二维数组并不是连续内存空间。二分查找是数组的典型问题，从设计算法角度来说分为“左闭右闭”与“左闭右开”。根据两种设计的方法不同对于mid的赋值与循环的判断条件也有不同。

例题 ：

对于该题，在编写二分查找时，利用left与right的向内移动判断中位数mid是否等于target这就是普通思路，但是循环判断条件时while(left <=  right)还是while(left < right),mid的赋值是mid-1还是别的；这里的差异主要在于在设计算法时是利用左闭右闭还是左闭右开。

1.左闭右闭（ [left, right] ）

根据左闭右闭的观点我们把target定义在了区间内部而不是边缘；所以右如下两点：

while(left <= right)，这时候因为left == right是有意义的，例如数组只有一个元素。

if(nums[mid] < target)这里的赋值要写为 mid+1，因为当前mid一定不是目标target，那么就要在接下来的查找过程中绕开当前元素。

class Solution {
    public int search(int[] nums, int target) {
        int low = 0, height = nums.length - 1;
           
        while(low <= height){
            int mid = (low + height)/2;
            if(nums[mid] < target) {
                low = mid + 1;               
            }else if(nums[mid] > target){
                height = mid - 1;
            }else {
                return mid;
            }
        }
        return -1;
    }
}

/**
 对于while循环内的判断条件，等于必须要写，如果数组时 [5] ，此时如果while循环判断只有小于就直接返回-1
/

2左闭右开

对比与左闭右闭 存在三处问题

1.right的赋值，在左闭右闭中right的赋值是数组长度减1，但是此处不需要减1，如果减1，在数组只有一个元素时，无法进入循环，

2.while内部写为while(low < height)，

3.对于右侧的编写height应该直接赋值为mid 也不需要减1，因为寻找的区间是左闭右开，所以选用等于mid。

class Solution {
    public int search(int[] nums, int target) {
        int low = 0, height = nums.length ;
           
        while(low < height){
            int mid = (low + height)/2;
            if(nums[mid] < target) {
                low = mid + 1;               
            }else if(nums[mid] > target){
                height = mid ;
            }else {
                return mid;
            }
        }
        return -1;
    }
}

例题 

本题可以依靠暴力破解，但是，快慢指针对于数组的题以及链表有着明显的优势。

class Solution {
    public int removeElement(int[] nums, int val) {
        
        int slowPoint = 0;
        for(int fastPoint = 0; fastPoint < nums.length; fastPoint++){
            // 快指针值和target相同则快指针移动，
            // 不同 快指针的值覆盖慢指针的值
            if(nums[fastPoint] != val){
                nums[slowPoint] = nums[fastPoint];
                slowPoint++;
            }
            
        }
        return slowPoint;
    }
}

也可以用相向指针，但是空间复杂度开销会变大。

本题也是双指针的写法，但是，对于27题在于，27题是无序的，可以在后面找到一个数字进行替换，但是本题如果采用27题的做法，则会产生重复的情况。

class Solution {
    public int removeDuplicates(int[] nums) {
        int slowPoint = 0;
        for(int fastPoint = 1; fastPoint < nums.length; fastPoint++){
            // 如果相等直接让快指针覆盖慢指针 ,慢指针不动
            if(nums[slowPoint] == nums[fastPoint]){
                nums[slowPoint] = nums[fastPoint];
            }else{
                slowPoint++;
                nums[slowPoint] = nums[fastPoint];
            }
        }
        return slowPoint+1;
    }
}

本题和27相似

使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。

右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。

注意到以下性质：

左指针左边均为非零数；

右指针左边直到左指针处均为零。

因此每次交换，都是将左指针的零与右指针的非零数交换，且非零数的相对顺序并未改变。

class Solution {
    public void moveZeroes(int[] nums) {
        int n = nums.length, slow = 0, fast = 0;
        while (fast < n) {
            if (nums[fast] != 0) {
                int temp = nums[slow];
                nums[slow] = nums[fast];
                nums[fast] = temp;
                slow++;
            }
            fast++;
        }
    }
}