代码随想录day1数组| 二分查找、双指针

小了白了兔白了又了

已于 2024-01-06 14:43:52 修改

阅读量794

点赞数 19

分类专栏：代码随想录文章标签：数据结构算法

于 2024-01-04 14:35:04 首次发布

本文链接：https://blog.csdn.net/2301_80193521/article/details/135364696

版权

代码随想录专栏收录该内容

4 篇文章 0 订阅

订阅专栏

参考：
代码随想录

文章目录

1.二分查找
2.双指针- 快慢指针的应用

1.二分查找

方法：采用左闭右闭的区间，
循环结束之后，left 指向最小的（第一个）比 key 大的元素，
right 指向最大的（最后一个）比key小的元素。

代码：

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

相关题目推荐：

1.1 搜索插入位置

链接：35.搜索插入位置
题目描述：

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。

方法：

在二分查找中，left左边一直比target小，right右边一直比target大，
所以在升序中插入位置是第一个比target大的元素位置，也就是left的位置，
所以直接返回left就可以了。

代码：

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

1.2 查找元素的第一个和最后一个位置

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

题目：

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target，返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

方法：

用两个指针来保存第一个与最后一个等于target的元素的位置
这样还是用左闭右闭的区间，还是二分查找的模板，在相等的时候判断一下，其他的就不变。

代码：

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int left = 0, right = nums.size() - 1;
        // 用两个指针来保存第一个与最后一个等于target的元素的位置
        int first = -1, last = -1;

        // 找第一个等于target的位置
        while (left <= right) {
            int middle = (left + right) / 2;
            if (nums[middle] == target) {
                first = middle; // 记录位置
                right = middle - 1; //重点,因为要找第一个等于target的位置，所以要往左边找
            } else if (nums[middle] > target) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }

        // 最后一个等于target的位置
        left = 0;
        right = nums.size() - 1;
        while (left <= right) {
            int middle = (left + right) / 2;
            if (nums[middle] == target) {
                last = middle; // 记录位置
                left = middle + 1; //重点,因为要找最后一个等于target的位置，所以要往右边找
            } else if (nums[middle] > target) {
                right = middle - 1;
            } else {
                left = middle + 1;
            }
        }
            return vector<int>{first, last};
    }
};

1.3 求x的平方根

链接：69.x 的平方根

题目：

给你一个非负整数 x ，计算并返回 x 的算术平方根。
由于返回类型是整数，结果只保留整数部分，小数部分将被舍去。

方法：

用二分查找来做，最后要的结果是向下取整，所以返回 left-1

代码：

class Solution {
public:
    int mySqrt(int x) {
        if (x == 1) { // 1要特殊处理
            return 1;
        }
        int l = 1, r = x - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (x / mid == mid) { // 如果用x > mid*mid，mid*mid可能太大会越界
                return mid;
            } else if (x / mid > mid) {
                l = mid + 1;
            } else {
                // x/mid < mid
                r = mid - 1;
            }
        }
        return l - 1;
    }
};

1.4 有效的完全平方数

链接：367.有效的完全平方数
题目：

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

方法：

PS: 和上面求x的平方根差不多，这里会判断一下能否整除。

代码：

class Solution {
public:
    bool isPerfectSquare(int num) {
        if (num == 1) { // 1要特殊处理
            return true;
        }
        int l = 1, r = num - 1;
        while (l <= r) {
            int mid = l + (r - l) / 2;
            if (num / mid == mid) { // num > mid*mid，mid*mid可能太大会越界
                // eg:5/2=2，但是5不是完全平方数
                // 所以判断是否可以整除，如果可以整除才是真正的完全平方数
                if (num % mid == 0) {
                    return true;
                } else {
                    return false;
                }
            } else if (num / mid > mid) {
                l = mid + 1;
            } else {
                // num/mid < mid
                r = mid - 1;
            }
        }
        return false;
    }
};

2.双指针- 快慢指针的应用

2.1 移除元素

链接：27.移除元素
题目：

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

方法：

快慢指针法，用两个指针，一个指针表示当前访问位置，一个指针指向实际位置。

代码：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 快慢指针法，用两个指针，一个指针表示当前访问位置，一个指针指向实际位置
        int r = 0, i = 0;
        while (i < nums.size()) {
            if (nums[i] != val) {
                nums[r++] = nums[i];
            }
            i++;
        }
        return r;
    }
};

2.2 删除排序数组中的重复项

链接：26.删除排序数组中的重复项
题目：

给你一个非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。然后返回 nums 中唯一元素的个数。

方法：

快慢指针法，用两个指针，一个指针表示当前访问位置，一个指针指向实际位置。

代码：

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        // 双指针法：fast指向当前元素下标，low指向实际被保存的最后一个元素下标
        int fast = 1, low = 0;
        // 从第二个元素开始判断
        while (fast < nums.size()) {
            if (nums[fast] != nums[low]) {
                nums[++low] = nums[fast];
            }
            fast++;
        }
        return low + 1;
    }
};

2.3 移动零

链接：283.移动零
题目：

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意，必须在不复制数组的情况下原地对数组进行操作。

我的方法一：

双指针法：fast指向当前元素下标，low指向实际被保存的最后一个元素下标，最后的位置全补上0

代码：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        // 双指针法：fast指向当前元素下标，low指向实际被保存的最后一个元素下标，最后的位置全补上0
        int fast = 0, low = 0;
        while (fast < nums.size()) {
            if (nums[fast] != 0) {
                nums[low++] = nums[fast];
            }
            fast++;
        }
        while (low < nums.size()) {
            nums[low++] = 0;
        }
    }
};

这里题目中要求不能复制数组，所以按照官方的答案，是用交换来实现的。
方法二（官方：）

使用双指针，左指针指向当前已经处理好的序列的尾部，右指针指向待处理序列的头部。
右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。

注意到以下性质：

左指针左边均为非零数；
右指针左边直到左指针处均为零。
因此每次交换，都是将左指针的零与右指针的非零数交换，且非零数的相对顺序并未改变。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        // 方法二：交换元素
        int fast = 0, low = 0;
        while (fast < nums.size()) {
            if (nums[fast] != 0) {
                swap(nums[low], nums[fast]);
                low++;
            }
            fast++;
        }
    }
};

2.4 比较含退格的字符串

链接：844.比较含退格的字符串
题目：

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

方法一：双指针

双指针法：fast指向当前元素下标，low指向实际被保存的最后一个元素下标。
（1）对于每一个字符串，都使用双指针来处理，遇到退格，指针low就回退一步，最终结果以low指针为结尾。
（2）两个字符串在一起比较，如果两个长度不一样，直接返回false，否则，长度一样，再一个一个字符串比较

代码：

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        // 对于每一个字符串，都使用双指针来处理，遇到退格，指针low就回退一步，最终结果以low指针为结尾。
        // 两个字符串在一起比较，如果两个长度不一样，直接返回false，否则，长度一样，再一个一个字符串比较

        // 对字符串s进行处理
        int low1 = 0, fast1 = 0;
        while (fast1 < s.length()) {
            if (s[fast1] == '#') {
                if (low1 > 0) { // low最小就是0的位置，不能再往回退了eg:s="#a#c"
                    low1--;
                }

            } else {
                s[low1++] = s[fast1];
            }
            fast1++;
        }

        // 对字符串t进行同样的处理
        int low2 = 0, fast2 = 0;
        while (fast2 < t.length()) {
            if (t[fast2] == '#') {
                if (low2 > 0) { // low最小就是0的位置，不能再往回退了
                    low2--;
                }
            } else {
                t[low2++] = t[fast2];
            }
            fast2++;
        }

        // 比较两个字符串
        if (low1 != low2) {
            return false;
        }
        for (int i = 0; i < low1; i++) {
            if (s[i] != t[i]) {
                return false;
            }
        }
        return true;
    }
};

方法二：栈，空间复杂度为O(2n)

这里直接使用字符串string，来作为栈，末尾添加和弹出，string都有相应的接口，最后比较的时候，只要比较两个字符串就可以了，比比较栈里的元素方便一些。

代码：

class Solution {
public:
    bool backspaceCompare(string S, string T) {
        string s; // 当栈来用
        string t; // 当栈来用
        for (int i = 0; i < S.size(); i++) {
            if (S[i] != '#') s += S[i];
            else if (!s.empty()) {
                s.pop_back();

        }
        for (int i = 0; i < T.size(); i++) {
            if (T[i] != '#') t += T[i];
            else if (!t.empty()) {
                t.pop_back();
            }
        }
        if (s == t) return true; // 直接比较两个字符串是否相等，比用栈来比较方便多了
        return false;
    }
};

2.5 有序数组的平方

链接：977.有序数组的平方
题目：

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

总的思路：先平方，然后在排序。

平方之后的数组，以0为界，向两边递增，由于我们得到了两个已经有序的子数组，因此就可以使用归并的方法进行排序了。

方法一：我刚开始的想法：从0开始，从中间向两边扩展，选择最小的元素。

使用两个指针分别指向位置0的两边，每次比较两个指针对应的数，选择较小的那个放入答案并移动指针。当某一指针移至边界时，将另一指针还未遍历到的数依次放入答案。
但是这样比较麻烦，，，

方法二：从两边向中间扩展，不断选择最大的元素。
代码：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            nums[i] = nums[i] * nums[i];
        }
        vector<int> result(nums.size(), 0);
        // 先平方，然后从0开始从中间分为两半，类似归并排序中的将两个有序数组合并，从中间向两边移动，不断选择最小的元素，
        //但是还要找0，看了答案知道这种方法叫做双指针法，换一种合并方法，从两边向中间移动，不断选择两个中最大的放到数组末尾
        int i = 0, j = nums.size() - 1, k = nums.size() - 1;
        while (i <= j) {
            if (nums[i] <= nums[j]) {
                result[k--] = nums[j--];
            } else {
                result[k--] = nums[i++];
            }
        }
        return result;
    }
};

小了白了兔白了又了

关注

19
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
代码随想录day1数组| 二分查找、双指针

链接34.在排序数组中查找元素的第一个和最后一个位置给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。输入：nums = [5,7,7,8,8,10], target = 8输出：[3,4]输入：nums = [5,7,7,8,8,10], target = 6输出：[-1,-1]方法。
复制链接

扫一扫