代码随想录算法训练营第一天| 704. 二分查找、35.搜索插入位置、27. 移除元素

704.二分查找

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

思路：题目难度较低，较为常规的二分法解题思路，本来一开始是想用递归来写，发现用while循环写更加简洁。

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

java

java数组长度表示：nums.length

注意区间左右开闭问题

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

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

35.搜索插入位置

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

请必须使用时间复杂度为 O(log n) 的算法。

思路：思路与上一题二分查找一致，只是将找不到的情况返回值更改

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size();
        while(left<right){
            int mid=(left+right)/2;
            if(nums[mid]==target){
                return mid;
            }
            else if(nums[mid]>target){
                right=mid;
            }
            else{
                left=mid+1;
            }
        }
        return left;
    }
};

java

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

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

• 相关推荐题目待二刷

• 34.在排序数组中查找元素的第一个和最后一个位置(opens new window)
• 69.x 的平方根
• 367.有效的完全平方数

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

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

思路：找到相等的点之后往左右找范围

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

    }
}

二刷：关于数组要检查下标范围，确保访问下标有效 

69. x 的平方根 

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

小变形但是没想出来。。。

class Solution {
    public int mySqrt(int x) {
        int left=0;
        int right=x;
        int ans=-1;
        while(left<=right){
            int mid=(left+right)/2;
            if((long)mid*mid<=x){
                ans=mid;
                left=mid+1;
            }
            else  right=mid-1;    
        }
        return ans;
    }
}

367. 有效的完全平方数

给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。

不能使用任何内置的库函数，如  sqrt 。

class Solution {
    public boolean isPerfectSquare(int num) {
        int left=0;
        int right=num;
        while(left<=right){
            int mid=(left+right)/2;
            if((long)mid*mid==num)  return true;    
            else if((long)mid*mid>num)  right=mid-1;       //记得把每一个都加上（long）
            else left=mid+1;
        }
        return false;
    }
}

只在第一个mid*mid写了（long）导致超时，记得全都加上 

27. 移除元素

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

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

解法一：一开始使用的是蛮力法

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

时间复杂度O(n^2)

空间复杂度O(1)

解法二：使用vector的erase函数

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        for(int i=0;i<nums.size();i++){
            if(nums[i]==val){
                nums.erase(nums.begin()+i);
                i--;
            }
        }
        return nums.size();
    }
};

tips:一开始犯了个错误关于erase的参数应该是迭代器

erase函数可以用于删除vector容器中的一个或者一段元素，在删除一个元素的时候，其参数为指向相应元素的迭代器，而在删除一段元素的时候，参数为指向一段元素的开头的迭代器以及指向结尾元素的下一个元素的迭代器；

解法三：双指针法

双指针法

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

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

很多同学这道题目做的很懵，就是不理解 快慢指针究竟都是什么含义，所以一定要明确含义，后面的思路就更容易理解了。删除过程如下：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowindex=0;
        for(int fastindex=0;fastindex<nums.size();fastindex++){
            if(nums[fastindex]!=val){
                nums[slowindex]=nums[fastindex];
                slowindex++;
            }
        }
        return slowindex;
    }
};

时间复杂度O(n)

空间复杂度O(1)

相关推荐题目待二刷

• 26.删除排序数组中的重复项
• 283.移动零
• 844.比较含退格的字符串
• 977.有序数组的平方

844. 比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

 双指针法：

一开始使用的解法是记录退格数然后获取当前index减去退格数获取当前字符，该解法错误因为可能跳过了#，#必须叠加不能退格，所以必须逐个字符遍历记录退格数以及逐个实现退格来解题。

class Solution {
    public boolean backspaceCompare(String s, String t) {
        int sindex=s.length()-1;
        int tindex=t.length()-1;
        int skips=0;           //记录当前需要退格数
        int skipt=0;
        while(sindex>=0||tindex>=0){
            char chs='\0';
            char cht='\0';
            while(sindex>=0){         //使用while循环直到找到第一个非#字符或者遍历完字符串
                if(s.charAt(sindex)=='#'){     //如果为#记录退格数并指向前一位
                    skips++;
                    sindex--;
                }
                else{
                    if(skips>0){         //如果不为#则判断是否需要退格
                        skips--;
                        sindex--;
                    }
                    else  break;
                }
            }          //此时的index为非#字符或者小于0
            if(sindex>=0)  chs=s.charAt(sindex);
            while(tindex>=0){
                if(t.charAt(tindex)=='#'){
                    skipt++;
                    tindex--;
                }
                else{
                    if(skipt>0){
                        skipt--;
                        tindex--;
                    }
                    else  break;
                }
            }
            if(tindex>=0) cht=t.charAt(tindex);
            if(chs==cht){
                sindex--;
                tindex--;
            }
            else{
                break;
            }  
        }
        if(sindex<0&&tindex<0)  return true;
        else  return false;
    }
}

 

第一天刷题希望可以坚持下去吧！