day 1 第一章 数组

数组

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

需要两点注意的是
・数组下标都是从0开始的。
・数组内存空间的地址是连续的
正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址

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

二分查找法

Leetcode: 704

Leetcode: 704: 二分查找

左闭右闭

class Solution {
    public int search(int[] nums, int target) {
    	int left = 0;
    	int right = nums.length - 1;
    	while (left <= right) {
        	int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
        	// int middle = left + ((right - left) >> 1);
        	if (nums[middle] > target) {
            	right = middle - 1;
        	} else if (nums[middle] < target) {
            	left = middle + 1;
        	} else {
            	return middle;
        	}
    	}
    	return -1;
    }
}

左闭右开

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

Leetcode: 35

Leetcode: 35: 搜索插入位置

左闭右闭

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

左闭右开

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

Leetcode: 34

Leetcode: 34: 在排序数组中查找元素的第一个和最后一个位置

解法1

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

解法2

class Solution {
    public int[] searchRange(int[] nums, int target) {
       int leftBorder = getLeftBorder(nums, target);
        int rightBorder = getRightBorder(nums, target);
        // 情况一
        if (leftBorder == -2 || rightBorder == -2) return new int[]{-1, -1};
        // 情况三
        if (rightBorder - leftBorder > 1) return new int[]{leftBorder + 1, rightBorder - 1};
        // 情况二
        return new int[]{-1, -1};
    }   
    int getRightBorder(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                right = middle - 1;
            } else { // 寻找右边界，nums[middle] == target的时候更新left
                left = middle + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }

    int getLeftBorder(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
                right = middle - 1;
                leftBorder = right;
            } else {
                left = middle + 1;
            }
        }
        return leftBorder;
    }
}

双指针法

Leetcode: 27

Leetcode: 27: 移除元素

解法1(暴力)

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

解法2

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

解法3(双指针)

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;
    }
}