leetcode:数组

已于 2023-01-08 15:51:07 修改
阅读量102 收藏
点赞数
文章标签： 算法
于 2022-12-16 10:15:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GOODCONG/article/details/128339013
版权

二分查找：

704：二分查找

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;
    }
};

35：搜索插入位置

 

 

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0;
        int right = n-1;

        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] >= target){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }
        return left;

    }
};

34：查找数组中，某个数字的起始位置和结束位置

 思路：分别利用二分查找，找到左右边界。返回最终结果

寻找target在数组里的左右边界，有如下三种情况：

  • 情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
  • 情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
  • 情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}

这三种情况都考虑到，说明就想的很清楚了。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftBorder = getLeftBorder(nums, target);
        int rightBorder = getRightBorder(nums, target);
        // 情况一
        if (leftBorder == -2 || rightBorder == -2) return {-1, -1};
        // 情况三
        if (rightBorder - leftBorder > 1) return {leftBorder + 1, rightBorder - 1};
        // 情况二
        return {-1, -1};
    }
private:
     int getRightBorder(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = -2; // 记录一下rightBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] > target) {
                right = middle - 1;
            } else { // 寻找右边界，nums[middle] == target的时候更新left
                left = middle + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }
    int getLeftBorder(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        int leftBorder = -2; // 记录一下leftBorder没有被赋值的情况
        while (left <= right) {
            int middle = left + ((right - left) / 2);
            if (nums[middle] >= target) { // 寻找左边界，nums[middle] == target的时候更新right
                right = middle - 1;
                leftBorder = right;
            } else {
                left = middle + 1;
            }
        }
        return leftBorder;
    }
};

69： X 的平方根。

思路：应用纯粹的数学公式。

class Solution {
public:
    int mySqrt(int x) {
        if (x == 0) {
            return 0;
        }
        int ans = exp(0.5 * log(x));
        return ((long long)(ans + 1) * (ans + 1) <= x ? ans + 1 : ans);
    }
};

最后的时候，需要验证一下，是否是正确的。因为，中间的数据换算，可能会导致，进位出现偏差。

还有就是，二分查找

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

 367：有效的完全平方数

 二分查找：

class Solution {
public:
    bool isPerfectSquare(int num) {
        int low = 1;
        int high = num;
        while (low <= high) {
            int mid = low + (high - low) / 2;       
            int t = num / mid;
            if (t == mid) {
                if (num%mid == 0) return true;
                low = mid + 1;
            } else if (t < mid) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return false;

    }
};

移除元素 力扣27

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

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

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

方法1：双指针。

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

        return m;

    }
};

方法2：双指针优化。

思路

如果要移除的元素恰好在数组的开头，例如序列 [1,2,3,4,5][1,2,3,4,5]，当 \textit{val}val 为 11 时，我们需要把每一个元素都左移一位。注意到题目中说：「元素的顺序可以改变」。实际上我们可以直接将最后一个元素 55 移动到序列开头，取代元素 11，得到序列 [5,2,3,4][5,2,3,4]，同样满足题目要求。这个优化在序列中 \textit{val}val 元素的数量较少时非常有效。

实现方面，我们依然使用双指针，两个指针初始时分别位于数组的首尾，向中间移动遍历该序列。

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

相关题目：

       26. 删除有序数组中的重复项

要求：

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

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

思路1：基于双指针。

示例：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int m = 1 ;
        for (int n = 1 ; n < nums.size() ; n++){
            
            if (nums[n] != nums[n-1]){
                nums[m] = nums[n] ;
                m++;
            }
        }

        return m;

    }
};

思路2：优化双指针

这是大部分题解都没有提出的，在这里提一下。

考虑如下数组：

此时数组中没有重复元素，按照上面的方法，每次比较时 nums[p] 都不等于 nums[q]，因此就会将 q 指向的元素原地复制一遍，这个操作其实是不必要的。

因此我们可以添加一个小判断，当 q - p > 1 时，才进行复制。

public int removeDuplicates(int[] nums) {
    if(nums == null || nums.length == 0) return 0;
    int p = 0;
    int q = 1;
    while(q < nums.length){
        if(nums[p] != nums[q]){
            if(q - p > 1){
                nums[p + 1] = nums[q];
            }
            p++;
        }
        q++;
    }
    return p + 1;
}

这里注意：语言是java

力扣：移动0  283

题目：

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

思路：

双指针+swap

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size();int l = 0, r = 0 ;

        while(r < n){

            if (nums[r]){
                swap(nums[l],nums[r]);
                l++;
            }
            r++;

        }

    }
};

力扣： 比较含退格的字符串  844

思路：

## 普通方法（使用栈的思路）

这道题目一看就是要使用栈的节奏，这种匹配（消除）问题也是栈的擅长所在，跟着一起刷题的同学应该知道，在栈与队列：匹配问题都是栈的强项，我就已经提过了一次使用栈来做类似的事情了。

**那么本题，确实可以使用栈的思路，但是没有必要使用栈，因为最后比较的时候还要比较栈里的元素，有点麻烦**。

这里直接使用字符串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;
    }
};
  • 时间复杂度:O(n + m)， n为S的长度，m为T的长度 ，也可以理解是O(n)的时间复杂度
  • 空间复杂度:O(n + m)

当然以上代码，大家可以发现有重复的逻辑处理S，处理T，可以把这块公共逻辑抽离出来，代码精简如下：

class Solution {
private:
string getString(const string& S) {
    string s;
    for (int i = 0; i < S.size(); i++) {
        if (S[i] != '#') s += S[i];
        else if (!s.empty()) {
            s.pop_back();
        }
    }
    return s;
}
public:
    bool backspaceCompare(string S, string T) {
        return getString(S) == getString(T);
    }

性能依然是：

  • 时间复杂度:O(n + m)
  • 空间复杂度:O(n + m)

思路2：双指针 从后往前走

当然还可以有使用 O(1) 的空间复杂度来解决该问题。

同时从后向前遍历S和T（i初始为S末尾，j初始为T末尾），记录#的数量，模拟消除的操作，如果#用完了，就开始比较S[i]和S[j]。

下面是动画演示：

https://code-thinking.cdn.bcebos.com/gifs/844.%E6%AF%94%E8%BE%83%E5%90%AB%E9%80%80%E6%A0%BC%E7%9A%84%E5%AD%97%E7%AC%A6%E4%B8%B2.gif

如果S[i]和S[j]不相同返回false，如果有一个指针（i或者j）先走到的字符串头部位置，也返回false。

代码如下：

class Solution {
public:
    bool backspaceCompare(string S, string T) {
        int sSkipNum = 0; // 记录S的#数量
        int tSkipNum = 0; // 记录T的#数量
        int i = S.size() - 1;
        int j = T.size() - 1;
        while (1) {
            while (i >= 0) { // 从后向前，消除S的#
                if (S[i] == '#') sSkipNum++;
                else {
                    if (sSkipNum > 0) sSkipNum--;
                    else break;
                }
                i--;
            }
            while (j >= 0) { // 从后向前，消除T的#
                if (T[j] == '#') tSkipNum++;
                else {
                    if (tSkipNum > 0) tSkipNum--;
                    else break;
                }
                j--;
            }
            // 后半部分#消除完了，接下来比较S[i] != T[j]
            if (i < 0 || j < 0) break; // S 或者T 遍历到头了
            if (S[i] != T[j]) return false;
            i--;j--;
        }
        // 说明S和T同时遍历完毕
        if (i == -1 && j == -1) return true;
        return false;
    }
};
class Solution {
public:
    bool backspaceCompare(string S, string T) {
        int i = S.length() - 1, j = T.length() - 1;
        int skipS = 0, skipT = 0;

        while (i >= 0 || j >= 0) {
            while (i >= 0) {
                if (S[i] == '#') {
                    skipS++, i--;
                } else if (skipS > 0) {
                    skipS--, i--;
                } else {
                    break;
                }
            }
            while (j >= 0) {
                if (T[j] == '#') {
                    skipT++, j--;
                } else if (skipT > 0) {
                    skipT--, j--;
                } else {
                    break;
                }
            }
            if (i >= 0 && j >= 0) {
                if (S[i] != T[j]) {
                    return false;
                }
            } else {
                if (i >= 0 || j >= 0) {
                    return false;
                }
            }
            i--, j--;
        }
        return true;
    }
};

这里还可以找到：字符串的相关题目，系列

  • 344 反转字符串
  • 541 反转字符串ii
  • 剑指offer  05 替换空格
  • 151 翻转字符串里面的 单词
  • 剑指offer 58 左旋转  字符串
  • 28 实现kmp  算法
  • 459 重复字符串 kmp  算法

 力扣：977 有序数组的平方

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

方法一：直接排序

思路与算法

最简单的方法就是将数组 \textit{nums}nums 中的数平方后直接排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> ans;
        for (int num: nums) {
            ans.push_back(num * num);
        }
        sort(ans.begin(), ans.end());
        return ans;
    }
};

复杂度分析

时间复杂度：O(n log n)O(nlogn)，其中 nn 是数组 \textit{nums}nums 的长度。

空间复杂度：O(log n)O(logn)。除了存储答案的数组以外，我们需要 O(logn) 的栈空间进行排序。

方法二：双指针
思路与算法

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        int negative = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                negative = i;
            } else {
                break;
            }
        }

        vector<int> ans;
        int i = negative, j = negative + 1;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
            else if (j == n) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else if (nums[i] * nums[i] < nums[j] * nums[j]) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
        }

        return ans;
    }
};

方法三：双指针
思路与算法

同样地，我们可以使用两个指针分别指向位置 00 和 n-1n−1，每次比较两个指针对应的数，选择较大的那个逆序放入答案并移动指针。这种方法无需处理某一指针移动至边界的情况，读者可以仔细思考其精髓所在。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> ans(n);
        for (int i = 0, j = n - 1, pos = n - 1; i <= j;) {
            if (nums[i] * nums[i] > nums[j] * nums[j]) {
                ans[pos] = nums[i] * nums[i];
                ++i;
            }
            else {
                ans[pos] = nums[j] * nums[j];
                --j;
            }
            --pos;
        }
        return ans;
    }
};

双指针的另外一种写法：

class Solution {
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;
    }
};

GOODCONG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
leetcode二维数组-LeetCode:力码
07-07
leetcode二维数组力码 列表 #605. 可以放置鲜花 #581。 最短的未排序连续子阵列 #566。 重塑矩阵 #624。 数组中的最大距离 #532。 数组中的 K-diff 对 #414。 第三个最大数 细节 #605. 可以放花 问题描述： 假设你有...
leetcode:数组、列表等基本原型的基本操作
05-15
在编程领域，数组和列表是...通过LeetCode上的这些题目，你可以深入理解数组和列表的操作，并锻炼你的编程思维，这对于任何Java开发者来说都是宝贵的技能。记得在实践中不断尝试，优化代码，以提高算法效率和代码质量。
算法刷题第二天：双指针--1
喜欢吃豆的博客
08-29 240
双指针--1
算法笔记5——补充
weixin_43971890的博客
05-05 326
约瑟夫问题
算法-算法笔记
qq_43535469的博客
07-16 326
剑指 Offer 03. 数组中重复的数字 做法 数组中找重复数字我们第一个能想到的就是一一遍历 然后拿hash表记录下来 只要有一个键的值超过了1 那就直接输出 我的办法也是 可开辟一个vectorcan每个数字值就是他的位置 然后出现一次的就把值标位false 下次再遇见can[i] == false这个值的时候就直接输出 更好的办法 核心思想 一个重要的点是题目中数一定都比总数量n小 所以如果没有重复的数字 在0-n这些坑里面应该放着0-n数字对齐 也就是0号坑里面一定是0 所以我们就在每次遍历的时候
【力扣刷题】Day2. 双指针（977. 有序数组的平方）
weixin_46480158的博客
03-23 1304
题目： 给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 笔记：链接（力扣） 一、直接排序 class Solution { public: vector<int> sortedS
leetcode-每日一题2022.1.14 查找和最小的 K 对数字
zy的博客
01-17 500
优先队列 二分
leetcode：合并数组
kk769997的博客
10-13 144
将两个数组看作两个队列，每次从队列头部取出较小的那个放入结果中。中，使合并后的数组同样按。
从零开始的leetCode：数组去重
我的学习之路
04-19 557
目录数组去重任务描述解决思路时间复杂度分析 数组去重 任务描述 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成，不需要管后面的数。 例： 给定数组 nums = [1,1,2], 输出：2 且nums = [1,2,-] 例： 给定数组 nums...
LeetCode:数组的最大子序和
iaibeyond的专栏
02-07 7400
从0推理最大子序列
LeetCode: 数组中的第K个最大元素以及寻找最小/最大的K个数
samoyan的博客,记录技术成长~
03-01 610
在未排序的数组中找到第k个最大的元素。请注意，你需要找的是数组排序后的第k个最大的元素，而不是第k个不同的元素。快速选择的平均时间复杂度为O(N)，最坏情况下的时间复杂度为O(N^2)，空间复杂度为O(1)。这种方法的时间复杂度为O(NlogN)，空间复杂度为O(1)（如果使用的是原地排序算法）。这种方法的时间复杂度为O(NlogK)，空间复杂度为O(K)。
leetcode-数组
02-08
这个名为 "leetcode-数组" 的压缩包文件很可能包含了与 LeetCode 上数组相关的编程挑战。数组是计算机科学中最基础且重要的数据结构之一，它在算法和程序设计中扮演着核心角色。 数组是一种线性数据结构，它按照...
丢失的最小正整数leetcode-LeetCode:力码
06-30
丢失的最小正整数leetcode LeetCode leetcode 题目(共 65 题) 1 两数之和 2 两数相加 3 无重复字符的最长子串 4 寻找两个正序数组的中位数 7 整数反转 9 回文数 13 罗马数字转整数 14 最长公共前缀 15 三数之和 16 ...
LeetCode去除数组重复元素-Leetcode:Leetcode总结
06-30
LeetCode去除数组重复元素 Leetcode Leetcode in Cpp Order by Tag 用c++刷leetcode（比较顺手），按照tag顺序，easy & medium Array 0001 Two Sum (Easy) 给定一个数组和一个数字，返回数组中两数之和为给定数字的...
36. Adam 算法详解
qq_41238579的博客
07-10 961
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1546
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 704
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
【排序 - 堆排序】
2302_80393814的博客
07-10 548
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
算法刷题笔记 KMP字符串（C++实现，并给出了求next数组的独家简单理解方式）
最新发布
hanmo22357的博客
07-12 797
一道经典且较难的算法题，给出了C++代码实现，以及自己对next数组求解的独家简单的理解方式。
Leetcode题目+解析+思路+答案.pdf
10-23
"Leetcode题解集合，包含数组、位操作、树结构和动态规划等多个算法领域的题目解析和答案" 这篇PDF文档是一个LeetCode题目的综合解析合集，旨在帮助学习者提升算法能力和编程技巧。LeetCode是一个在线平台，提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值