leetcode刷题|day1 数组

saufmoi

已于 2023-03-09 19:37:36 修改

阅读量51

点赞数

文章标签：算法 Powered by 金山文档

于 2023-03-01 17:42:29 首次发布

本文链接：https://blog.csdn.net/saufmoi/article/details/129276253

版权

27. 移除元素 - 力扣（LeetCode）

第一次刷算法题，数据结构和c++都学得不是很好，随手记录一下，见证成长！

暴力解法

// 时间复杂度：O(n^2)// 空间复杂度：O(1)
classSolution {public:
    intremoveElement(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;

    }

双指针法

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

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

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

// 时间复杂度：O(n)// 空间复杂度：O(1)
classSolution {public:
    intremoveElement(vector<int>& nums, int val){
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

相关题目推荐

26. 删除有序数组中的重复项 - 力扣（LeetCode）（注意！！！slowIndex=0的数据一定是不重复的！！！）

classSolution 
{public:
    intremoveDuplicates(vector<int>& nums){
        if (nums.empty()) return0; // 别忘记空数组的判断int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < (nums.size() - 1); fastIndex++){
            if(nums[fastIndex] != nums[fastIndex + 1]) 
            { // 发现和后一个不相同
                nums[++slowIndex] = nums[fastIndex + 1]; //slowIndex = 0 的数据一定是不重复的，所以直接 ++slowIndex
            }
        }
        return slowIndex + 1; //别忘了slowIndex是从0开始的，所以返回slowIndex + 1
    }
};

283. 移动零 - 力扣（LeetCode）

void moveZeroes(vector<int>& nums) {
    int j = 0;
    for(int i = 0 ; i < nums.size(); i++)
    {
        if(nums[i] != 0)
        {
            nums[j] = nums[i];
            j++;
        }
    }
    while(j < numsSize)
    {
        nums[j++] = 0;
    }
}

844. 比较含退格的字符串 - 力扣（LeetCode）

977. 有序数组的平方 - 力扣（LeetCode）

暴力解法：先平方再排序

classSolution {public:
    vector<int> sortedSquares(vector<int>& A){
        for (int i = 0; i < A.size(); i++) {
            A[i] *= A[i];
        }
        sort(A.begin(), A.end()); // 快速排序return A;
    }
};

双指针法

i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

classSolution {public:
    vector<int> sortedSquares(vector<int>& A){
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

704. 二分查找 - 力扣（LeetCode）

第一种写法，我们定义 target 是在一个在左闭右闭的区间里，**也就是[left, right] （这个很重要非常重要）**。

区间的定义这就决定了二分法的代码应该如何写，**因为定义target在[left, right]区间，所以有如下两点：**

while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=

if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效，所以用 <=
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

二分查找步骤：

前提：是已经排好序的数列

循环条件：left<=right

1)为数组初始化下标left=0和right=nums.size()-1;将数列列出来并找到中间值，将中间值与目标值进行比较；

2)若目标值大于中间值，说明要查找的数据在数列的右半段。此时不考虑左半段的数据，更新left = mid+1，对右半段的数据再进行分割，找中间值，循环这一操作，直到target=nums[mid];

3)若目标值小于中间值，说明要查找的数据在数列的左半段。此时不需要考虑右半段的数据，更新right=mid-1，对左半段的数据再进行分割，找中间值，循环这一操作，直到target=nums[mid]。

### 二分法第二种写法

如果说定义 target 是在一个在左闭右开的区间里，也就是[left, right) ，那么二分法的边界处理方式则截然不同。

有如下两点：

while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的

if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]

// 版本二classSolution {public:
    intsearch(vector<int>& nums, int target){
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } elseif (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == targetreturn middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值return-1;
    }
};

相关题目推荐

35. 搜索插入位置 - 力扣（LeetCode）

使用二分查找法，但是要注意最后的返回值问题！

classSolution {public:
    intsearchInsert(vector<int>& nums, int target){
        int n = nums.size();
        int left = 0;
        int right = n - 1; // 定义target在左闭右闭的区间里，[left, right]
        while (left <= right) { // 当left==right，区间[left, right]依然有效
        int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
        if (nums[middle] > target) {
                right = middle - 1; // target 在左区间，所以[left, middle - 1]
            } elseif (nums[middle] < target) {
                left = middle + 1; // target 在右区间，所以[middle + 1, right]
            } else { // nums[middle] == targetreturn middle;
            }
        }
        // 分别处理如下四种情况
        // 目标值在数组所有元素之前  [0, -1]
        // 目标值等于数组中某一个元素  return middle;
        // 目标值插入数组中的位置 [left, right]，return  right + 1
        // 目标值在数组所有元素之后的情况 [left, right]，这是右闭区间，所以  return right + 1
        return right + 1;
    }
};

34. 在排序数组中查找元素的第一个和最后一个位置 - 力扣（LeetCode）

69. x 的平方根 - 力扣（LeetCode）

此题毫无思路,防止溢出mid = left + (right - left)/2;

classSolution{
    public int mySqrt(int x) {
        if(x==0) {
            return0;
        }
        int left = 1, mid, right = x;
        while(left<=right) {
            mid = left + (right - left)/2;
            if(x/mid < mid) {
                right = mid - 1;
            } elseif(x/mid > mid) {
                left = mid + 1;
            } else {
                return mid;
            }
        }
        returnright;
    }
}