Day1 数组 part01

二分查找

Leetcode: 704

1. 闭区间写法 Python

class Solution(object):
    def search(self, nums, target):
        left = 0
        right = len(nums) - 1
        while (left <= right):
            middle = left + ((right - left) >> 1)
            if (nums[middle] < target):
                left = middle + 1
            elif (nums[middle] > target):
                right = middle - 1
            else:
                return middle
        return -1

2. 左闭右开写法 Python

class Solution(object):
    def search(self, nums, target):
        left = 0
        right = len(nums)
        while (left < right):
            middle = left + ((right - left) >> 1)
            if (nums[middle] > target):
                right = middle
            elif (nums[middle] < target):
                left = middle + 1
            else:
                return middle
        return -1

3. 闭区间写法 Java

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) >> 1);
            if (nums[middle] < target) {
                left = middle + 1;
            } else if (nums[middle] > target) {
                right = middle - 1;
            } else {
                return middle;
            }
        }
        return -1;
    }
}

4. 左闭右开写法 Java

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.length;
        while (left < right) {
            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

1. 闭区间写法 Python3

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        left = 0
        right = len(nums) - 1
        while (left <= right):
            middle = left + ((right - left) >> 1)
            if (nums[middle] < target):
                left = middle + 1
            elif (nums[middle] > target):
                right = middle - 1
            else:
                return middle
        return left

2. 左闭右开写法 Java

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

相关题目 Leetcode: 34

Java 先二分判断有无，若有记录找到的位置分别进行二分查找，寻找左界右界

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        boolean exist = false;
        int note = 0;
        while (left <= right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] < target) {
                left = middle + 1;
            } else if (nums[middle] > target) {
                right = middle - 1;
            } else {
                exist = true;
                note = middle;
                break;
            }
        }
        if (!exist) return new int[]{-1, -1};
        int posLeft = searchLeft(nums, note, target);
        int posRight = searchRight(nums, note, target);
        return new int[]{posLeft, posRight};
    }

    int searchLeft(int[] nums, int note, int target) {
        int left = 0;
        int right = note;
        while (left <= right) {
            int middle = left + ((right - left) >> 1);
            if (nums[middle] < target) {
                left = middle + 1;
            } else if (nums[middle] == target) {
                right = middle - 1;
            }
        }
        return left;
    }

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

移除元素

Leetcode: 27

1. 双指针快慢指针 Python3

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        slowIndex = 0
        for fastIndex in range(len(nums)):
            if(val != nums[fastIndex]):
                nums[slowIndex] = nums[fastIndex]
                slowIndex += 1
        return slowIndex

2. 双指针相向指针 Python3

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        leftIndex = 0
        rightIndex = len(nums) - 1
        while (leftIndex <= rightIndex):
            while (leftIndex <= rightIndex and nums[leftIndex] != val):
                leftIndex += 1
            while (leftIndex <= rightIndex and nums[rightIndex] == val):
                rightIndex -= 1
            if (leftIndex < rightIndex):
                nums[leftIndex] = nums[rightIndex]
                leftIndex += 1
                rightIndex -= 1
        return leftIndex

3. 双指针快慢指针 Java

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];
        }
        return slowIndex;
    }
}

4.双指针相向指针 Java

class Solution {
    public int removeElement(int[] nums, int val) {
        int leftIndex = 0;
        int rightIndex = nums.length - 1;
        while (leftIndex <= rightIndex) {
            while (leftIndex <= rightIndex && nums[leftIndex] != val) {
                leftIndex++;
            }
            while (rightIndex >= leftIndex && nums[rightIndex] == val) {
                rightIndex--;
            }
            if (leftIndex < rightIndex) {
                nums[leftIndex++] = nums[rightIndex--];
            }
        }
        return leftIndex;
    }
}