代码随想录算法训练营day01

最新推荐文章于 2024-08-15 14:10:26 发布

peach2580

最新推荐文章于 2024-08-15 14:10:26 发布

阅读量176

点赞数

文章标签：算法数据结构 java Powered by 金山文档

本文链接：https://blog.csdn.net/peach2580/article/details/128798230

版权

704. 二分查找

题目链接

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

思路

普通循环遍历

一趟循环结束，找到就返回下标，没有找到就返回-1，缺点是没有利用升序

时间复杂度O(n)，空间复杂度O(1)

二分查找

二分查找重点在于有序，可以避免不必要的比较

查找次数下降，降低时间复杂度

设置头指针和尾指针，计算中间指针

如果tar = nums[mid]就返回

如果tar > nums[mid]就++head（注意细节，不能是head++，必须先自增再赋值

如果tar < nums[mid]就--end

循环结束条件：head <= end，经过讨论，=的时候需要再比较一次，不能是head<end

循环结束，仍未比较成功，说明数组中不存在target，返回-1

时间复杂度O(logn)，空间复杂度O(1)

代码

//普通循环
class Solution {
    public int search(int[] nums, int target) {
        for (int i = 0; i < nums.length; i++) {//对数组进行遍历
            if (nums[i] == target){//找到target
                return i;//就返回对应的下标
            }
        }
        return -1;//循环结束没有找到，就返回-1
    }
}

//二分查找
class Solution1 {
    public int search(int[] nums, int target) {
        int head = 0;
        int end = nums.length - 1;//左闭右闭区间
        int mid;
        while (head <= end) {
            mid = head + (end - head) / 2;//注意，防止整数溢出
            if (nums[mid] > target) {
                end = --mid;//--必须写在前面
            }else if (nums[mid] < target){
                head = ++mid;
            }else {
                return mid;
            }
        }
        return -1;//循环结束，没有找到，返回-1
    }
}

35.搜索插入位置

题目链接

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

你可以假设数组中无重复元素。

思路

这道题的难点在于，如果没有在原数组中找到target，需要返回插入的位置

经过分析，循环结束时，要么触发找到target，返回mid即可，和普通二分法逻辑相同

要么没有找到target，那么由于head和end对向运动且退出循环，必有head = end + 1；经过分析，回head即为要插入的位置

为什么head是要插入的位置？

四种情况

target在数组中，直接return mid

target比所有元素小，应该返回0；每次比较时，都是end向head移动，直到二者重合为0，下一次比较，end = -1，因此返回head = 0合理

target比所有元素大，应该返回nums.length；每次比较是head向end移动，直到二者重合为nums.length-1，下一次比较，head向前移动，合理

target在某两个元素间，比如[0 1 2 3 5 6] [0 1 2 3 5]，target=4，head=end时，一定在要插入位置或要插入位置的前一个。经过head或者end的移动，可以得到跳出循环时head的位置就是要插入的位置

时间复杂度O(logn)，空间复杂度O(1)

二分法使用条件：有序数组，无重复元素

代码

//二分查找
class Solution {
    public int searchInsert(int[] nums, int target) {
        int head = 0;
        int end = nums.length - 1;
        int mid;
        while (head <= end){
            mid = head + (end - head) / 2;
            if (nums[mid] < target){
                head = mid + 1;
            } else if (nums[mid] > target) {
                end = mid - 1;
            }else {
                return mid;//找到了，就返回mid，跳出循环
            }
        }
        return head;//最终没有找到，一定右head=end+1，经过分析，head即为要插入的位置
    }
}

27. 移除元素

题目链接

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

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

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

思路

暴力解法需要循环两次

一次找需要移除的元素，一次对数组进行更新（需要把后面的元素均移动），时间复杂度是O(n2)

暴力解法优点在于不会打乱原列表元素的顺序，缺点在于时间复杂度略高

原地移除数组的元素，可以考虑把后面位置的元素更换到前面位置，考虑双指针

定义一个快指针遍历数组，一个慢指针最开始在数组头部

如果快指针位置元素是target，就是要删除的，慢指针不移动，快指针移动

如果快指针位置元素不是target，不是要删除的，这个元素要放到慢指针的位置，再把慢指针向后移动

快指针遍历到数组末尾，遍历结束

时间复杂度O(n)

双指针法：

通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组

慢指针：指向更新后新数组下标的位置

代码

//暴力遍历，两层循环
class Solution1 {
    public int removeElement(int[] nums, int val) {
        int len = nums.length;
        for (int i = 0; i < len; i++) {
            if (nums[i] == val) {//找到了val，把后面的元素全部向前移动以为
                for (int j = i; j < len - 1; j++) {//注意是len-1，防止下标越界
                    nums[j] = nums[j + 1];
                }
                i--;//每更新一次数组，i要-1，从上次的位置重新比较
                len--;//更新数组后长度-1
            }
        }
        return len;
    }
}

//双指针法
class Solution {
    public int removeElement(int[] nums, int val) {
        int s = 0;
        for (int f = 0; f < nums.length ; f++){//快指针遍历数组
            if (nums[f] != val){//如果不是val
                nums[s] = nums[f];//慢指针元素更新
                s++;//慢指针移动
            }
        }//快指针处元素是target，快指针移动即可，慢指针元素不更新
        return s;//返回慢指针，就是更新后数组的长度
    }
}