算法与数据结构刷题第一天

704. 二分查找

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

这个没啥好说的，都做得出来。

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        for i in range(len(nums)):
            if nums[i]==target:
                return  i

        return  -1

 27. 移除元素

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

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

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

java暴力实现：

// 时间复杂度：O(n^2)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int size = nums.size();
        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--; // 因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                size--; // 此时数组的大小-1
            }
        }
        return size;

    }
};

java测试用例（chatGPT生成)：：

public class Test {
    private Solutions s = new Solutions();

    @Test
    public void test1() {
        int[] nums = {3, 2, 2, 3};
        int res = 2;
        assert s.removeElement(nums, 3) == res;
        int[] expected = {2, 2};
        for (int i = 0; i < res; i++)
            assert nums[i] == expected[i];
    }

    @Test
    public void test2() {
        int[] nums = {0, 1, 2, 2, 3, 0, 4, 2};
        int res = 5;
        assert s.removeElement(nums, 2) == res;
        int[] expected = {0, 1, 3, 0, 4};
        for (int i = 0; i < res; i++)
            assert nums[i] == expected[i];
    }
}

python暴力实现：

class Solution:
    def removeElement(self, nums, val) :
        nums_len=len(nums)
        i=0
        while i<nums_len:
            if nums[i]==val:
                for j in range(i+1,nums_len):
                    nums[j-1]=nums[j]
                nums_len-=1
                i-=1
            i+=1
        return nums_len

python测试用例（chatGPT生成)：

s = Solution()

nums = [3,2,2,3]
assert s.removeElement(nums, 3) == 2
assert nums[:2] == [2, 2]

nums = [0,1,2,2,3,0,4,2]
assert s.removeElement(nums, 2) == 5
assert nums[:5] == [0, 1, 3, 0, 4]

做这道题的时候在循环方面踩了一个坑：

java中的第一层for循环中i++,可以自增，在此基础上可以与i--配合，使第一层for循环再次回到原位置。

坑来了：

python就不能套Java的逻辑，因为python循环是for i in range 形式，已经提前规定好值，无法做到上述java的工作。

python解决路径：第一层循环使用while语句和i+=1，实现jave第一层循环的作用。

 python双指针实现：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        # 快慢指针
        fast = 0  # 快指针
        slow = 0  # 慢指针
        size = len(nums)
        while fast < size:  # 不加等于是因为，a = size 时，nums[a] 会越界
            # slow 用来收集不等于 val 的值，如果 fast 对应值不等于 val，则把它与 slow 替换
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow