数组与字符串专题

已于 2024-06-12 13:40:56 修改
阅读量193 收藏
点赞数 2
文章标签： 算法 leetcode 职场和发展
于 2024-05-23 17:51:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69551472/article/details/139154111
版权

,## 27.移除元素
在这里插入图片描述
双指针法

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

优化

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

普通方法

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 就是简单筛选
        vector<int> result;
        int num = 0;
        for(int i=0 ; i< nums.size() ; i++) {
            if(nums[i] != val) {
                result.push_back(nums[i]);
                num++;
            } 
        }

        // 剩下的
        for(int i  =0; i< nums.size() - num; i++) {
            result.push_back(val);
        }
        nums = result;
    return num;
    }
};

121 买卖股票的最佳时机

在这里插入图片描述
思路
每次遍历, 算出,如果是最低底价买入,收益如何?? 并且记录一下最低价

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int inf = 1e9;
        int minprice = inf;
        int maxprofit  = 0;

        for(auto price : prices) {
            maxprofit = max(maxprofit , price-minprice);
            minprice = min(minprice, price);
        }
        return maxprofit ;
    }
};

169多数元素

在这里插入图片描述
我写的答辩code
排序 + 遍历 + 每次判断

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int nums_size = nums.size();
        // 排序遍历
        int sum = 1;
        int index = 0;  // 下标
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size()-1; i++) {
            if(nums[i] == nums[i+1]) {
                sum++; // 总数
                if(sum > nums_size/2) {
                    return nums[i];
                }
            } else {
                 if(sum > nums_size/2) {
                    return nums[i];
                } else {
                    sum =1;
                }
            }
        }
    return nums[0];
    }

};

投票法

class Solution {
public:
    int majorityElement(vector<int> &nums) {
        int candidate = 0; // 候选数字 
        int count = 0;

        for (int num : nums) {
            if (count == 0) {
                candidate = num;
            }
            count += (candidate == num) ? 1 : -1;
        }
        return candidate;
    }
};

数学
在这里插入图片描述

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() / 2];
    }
};

122. 买卖股票的最佳时机II

在这里插入图片描述
我的思路
只要后天一天比前一天大, 我就可以赚, 然后累加就好

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        // 可以理解成有一个数字
        // 1 5 3 6 
        int prices_size = prices.size();
        if(prices_size == 1) {
            return 0;
        }
        // 下面
        int profit = 0;
        for(int i = 1; i< prices_size; i++) {
            if(prices[i] > prices[i-1]) {
                int  Difference= prices[i]-prices[i-1];
                profit += Difference;
            }
        }
        return profit;
    }
};
```![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/fef3e4e4eb11474a92b3183f2b532285.png)


**官方贪心**

```c++
class Solution {
public:
    int maxProfit(vector<int>& prices) {   
        int ans = 0;
        int n = prices.size();
        for (int i = 1; i < n; ++i) {
            ans += max(0, prices[i] - prices[i - 1]);
        }
        return ans;
    }
};

动态规划
在这里插入图片描述

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int dp[n][2];
        dp[0][0] = 0, dp[0][1] = -prices[0];
        for (int i = 1; i < n; ++i) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }
        return dp[n - 1][0];
    }
};

55. 跳跃游戏

在这里插入图片描述
题解
在这里插入图片描述

class Solution {
public:
    bool canJump(vector<int>& nums) {
         int k = 0;
        for (int i = 0; i < nums.size(); i++) {
            // i 表示下标 k 表示最大的位移距离
            if (i > k) return false;
            k = max(k, i + nums[i]);
        }
        return true;
    }
};

H指数

在这里插入图片描述
倒序+遍历判断
这里最重要的是 k 的判断

class Solution {
public:
    int hIndex(vector<int>& citations) {
        int hIndex_size = citations.size();
        int k = 0;

        // 排序
        sort(citations.begin(),citations.end());
        for(int i = hIndex_size-1; i>=0 ; i--) {
            if(citations[i] && citations[i] > k) {   
                k++;
            } 
        }
        return k;
    }
};

统计所有的次数

class Solution {
public:
    int hIndex(vector<int>& citations) {
        int n = citations.size(), tot = 0;
        vector<int> counter(n + 1);
        for (int i = 0; i < n; i++) {
            if (citations[i] >= n) {
                counter[n]++;
            } else {
                counter[citations[i]]++;
            }
        }
         for (int i = n; i >= 0; i--) {
            tot += counter[i];
            if (tot >= i) {
                return i;
            }
        }
        return 0;
    }
};

跳跃游戏II

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int jump(vector<int>& nums) {
        // 跳到最后一个元素最少的次数
        int start = 0;
        int end = 1;
        int ans = 0; // 次数
        while(end < nums.size()) {
            int maxPos = 0;  // 每一次都初始化一下最大的距离
            for(int i = start; i< end; i++) {
                maxPos = max(maxPos, i+nums[i]);
            }
            // 更新 start end
            start = end;
            end = maxPos+1;
            ans++;
         }
         return ans;
    }
};

轮回数组

在这里插入图片描述
太妙了,如果纯简单模拟的话,会有很多问题
就比如, 长度只有1 ,然后k值为3
简单模拟是不可行的

class Solution {
public:
    void rotate(vector<int>& nums, int k) { 
        // 这里本质就一个循环
        int n = nums.size(); // 长度
        vector<int> result(n);
        for(int i = 0; i< n; i++) {
            result[(i+k)%n] = nums[i];
        }
        // 拷贝到原来的数组
        nums.assign(result.begin(),result.end());
    }
};

除自身以外的的乘积

在这里插入图片描述

暴力 超时

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        // 输出answer  输出是 num[i] 除 num[i] 之外元素的乘积
        int sum = 1;
        int n = nums.size();
        vector<int> result(n);

        for(int i = 0; i< n; i++) {
            for(int j = 0; j <n; j++) {
                if(i != j) {
                    sum *= nums[j];
                }
            }
            result[i] = sum;
            sum = 1;
        }
    
        return result;
    }
};

分类讨论 + 使用除法

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        // 输出answer  输出是 num[i] 除 num[i] 之外元素的乘积
        int sum = 1;
        int sum2 = 1;
        int n = nums.size();
        int count = 0; // 记录0的数量
        // 下面进行优化
        for(int i = 0; i< n; i++) {
            if(nums[i] == 0) {
                count++;
            }
            sum*=nums[i];
            if(nums[i] != 0) {
                sum2*=nums[i];
            }
        }
        // 分情况
        if(sum == 0) {
            if(count > 1) {
                for(int i = 0; i< n; i++) {
                    nums[i] = 0;
                }
            } else {
                for(int i = 0; i< n; i++) {
                    if(nums[i] == 0) {
                        nums[i] = sum2;
                    } else {
                        nums[i] = 0;
                    }
                }
            }
        } else {
            for(int i = 0; i< n; i++) {
                nums[i] = sum / nums[i];
            }
        }
        return nums;
       
    }
};

使用两个数组建立每一个下标左右两边的乘积

在这里插入图片描述

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();

        // L 和 R 分别表示左右两侧的乘积列表
        vector<int> L(length, 0), R(length, 0);

        vector<int> answer(length);

        // L[i] 为索引 i 左侧所有元素的乘积
        // 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
        L[0] = 1;
        for (int i = 1; i < length; i++) {
            L[i] = nums[i - 1] * L[i - 1];
        }

        // R[i] 为索引 i 右侧所有元素的乘积
        // 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
        R[length - 1] = 1;
        for (int i = length - 2; i >= 0; i--) {
            R[i] = nums[i + 1] * R[i + 1];
        }

        // 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
        for (int i = 0; i < length; i++) {
            answer[i] = L[i] * R[i];
        }

        return answer;
    }
};

加油站

在这里插入图片描述

下面这种方案无法实现,我本来是想找到差值最大的点,然后开始验证,32/42

class Solution {
public:
    int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {
        // 找出差值最大的下标
        int  n = gas.size();
        int max_index = 0;
        int max = INT_MIN; 
        for(int i = 0; i< n; i++) {
            int num = gas[i] - cost[i];
            if(num > max) {
                max = num;
                max_index = i;
            }
        }
        int gas_sum = 0;
        // 找出最大下标 开始验证
        for(int i= max_index; ;) {
            gas_sum = gas_sum + gas[i] - cost[i];
            if(gas_sum <0) {
                return -1;
            }
            i = (i+1)%n; // 循环
            if(i == max_index ) {
                break;
            }
        }
    return max_index;
    }
};

贪心

class Solution {
   public int canCompleteCircuit(int[] gas, int[] cost) {
       int n = gas.length;
       int sum = 0;
       int min = 0; 
       int idx = 0;
       for (int i = 0; i < n; i++) {
           sum += gas[i] - cost[i];
           if (sum < min) {
               min = sum;
               idx = i + 1;
           }
       }
       return sum < 0 ? -1 : idx;
   }
}

罗马数字转整数

在这里插入图片描述
重点
这里使用一个 unorder_map 进行记录 键-值 关系

class Solution {
public:
    int romanToInt(string s) {
        // 特殊情况 
        unordered_map<char,int> symbolValues = {
            {'I', 1},
            {'V', 5},
            {'X', 10},
            {'L', 50},
            {'C', 100},
            {'D', 500},
            {'M', 1000},
        };
        // 下面进行遍历,然后输出
        int result = 0;
        for(int i = 0; i< s.size(); i++) {
            int value = symbolValues[s[i]];
            if(i < s.size()-1 && value < symbolValues[s[i+1]]) {
                result -= value;
            } else {
                result += value;
            }
        }
        return result;
    }

};

6. Z字形变换


在这里插入图片描述
题解

这里可以这样理解
遍历原来的字符串
然后观察 Z 形 可以发现
就按照列进行放置
然后如果是 第一行 就 往下面走 也就是 +1
如果到了最后一行( numRows -1) 往上走 也就是 -1
知道到达第一行 ( i == 0)

class Solution {
public:
    string convert(string s, int numRows) {
        if(numRows <2) {
            return s;
        }
        vector<string> rows(numRows);
        int i = 0; int flag = -1;
        for(char c:s ) {
            rows[i].push_back(c);
            if(i ==0 || i == numRows-1) {
                flag = -flag;
            }
            i += flag;
        }
        string res;
        for(const string &row : rows ) {
            res += row;
        }
        return res;
 
    }
};

13.

在这里插入图片描述

模拟

class Solution {
public:
// 表示 数字 和 罗马数字
    string intToRoman(int num) {
        const pair<int, string> valueSymbols[] = {
            {1000, "M"},
            {900,  "CM"},
            {500,  "D"},
            {400,  "CD"},
            {100,  "C"},
            {90,   "XC"},
            {50,   "L"},
            {40,   "XL"},
            {10,   "X"},
            {9,    "IX"},
            {5,    "V"},
            {4,    "IV"},
            {1,    "I"},
        };
        string roman;
        for(const auto &[value, symbol] : valueSymbols) {
            while(num >= value) {
                num -= value;
                roman += symbol;
            }
            if(num == 0) {
                break;
            }
        }
        return roman;
    }
};

补充:
当然可以。范围基于的for循环是一种非常实用的语法，它允许你遍历容器中的所有元素，而无需手动管理迭代器或索引。以下是一些使用这种语法的例子：

1. 遍历数组

假设我们有一个整数数组，我们想要打印出每个元素：

int numbers[] = {1, 2, 3, 4, 5};
for (int num : numbers) {
    cout << num << " ";
}
// 输出: 1 2 3 4 5

2. 遍历std::vector

对于std::vector，范围基于的for循环同样适用：

#include <vector>
std::vector<string> fruits = {"apple", "banana", "cherry"};
for (const auto &fruit : fruits) {
    cout << fruit << " ";
}
// 输出: apple banana cherry

3. 遍历std::map

如果你有一个std::map，你可以遍历它的键值对：

#include <map>
std::map<int, std::string> ageMap = {{1, "Alice"}, {2, "Bob"}, {3, "Charlie"}};
for (const auto &pair : ageMap) {
    cout << "Key: " << pair.first << ", Value: " << pair.second << endl;
}
// 输出:
// Key: 1, Value: Alice
// Key: 2, Value: Bob
// Key: 3, Value: Charlie

4. 遍历std::pair

对于std::pair，你可以使用解构来分别获取两个元素：

std::pair<int, std::string> person(1, "John");
for (const auto &[key, value] : std::initializer_list<std::pair<int, std::string>>{{person}}) {
    cout << "Key: " << key << ", Value: " << value << endl;
}
// 输出: Key: 1, Value: John

5. 遍历字符串

字符串也可以使用范围基于的for循环遍历：

std::string greeting = "Hello";
for (char c : greeting) {
    cout << c << " ";
}
// 输出: H e l l o

这些例子展示了范围基于的for循环在不同容器和数据结构中的使用方式。通过使用这种语法，你可以写出更简洁、更易于理解的代码。

爱敲代码小黑
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数组与字符串总结
m0_46335449的博客
12-01 842
重点：多维数组转化为一维数组公式，以及特殊矩阵的存储，还有字符串匹配算法
数组与字符串方法总结
m0_69068349的博客
02-26 455
数组与字符串方法总结
数组和字符串的常用方法总结
xy2041622796的博客
02-26 1154
数组和字符串的常用方法总结
C语言基础知识梳理（二）数组和字符串专题
qq_46485137的博客
10-06 678
1）数组定义的基本格式：数据类型数组名[元素个数]={值1, 值2, 值3}；数组名不仅表示该数组的名字，还可以表示该数组的首地址，这种给所有元素都复制，称为“完全初始化”，这个时候，[ ]里的元素个数可以省略。2）如果定义数组的时候，{ }中的数值个数
php 字符串转换数组,PHP数组与字符串相互转换
weixin_42295528的博客
03-09 605
PHP数组与字符串相互转换字符串与数组的转换在程序开发过程中经常使用，PHP 主要使用 explode()函数和 implode()函数实现，下面我们分别进行详细讲解。1.使用 explode()函数将字符串转换成数组explode()函数将字符串依指定的字符串或者字符(separator)切开。语法格式如下;array explode(string separator,string string...
C#实现char字符数组与字符串相互转换的方法
08-31
本篇文章将详细阐述C#中实现char字符数组与字符串相互转换的方法。 一、字符串转换为字符数组 当你有一个字符串（string）并且需要将其分解为单个字符以便处理时，可以使用`ToCharArray()`方法。这个方法会将整个...
字符串专题文档
08-20
字符串专题资料中，可能包含以下内容：字符串的基础概念、常用操作方法详解、各种编程语言中的字符串处理差异、正则表达式教程、编码解码原理及实践、字符串在不同场景的应用案例等。通过深入学习这些内容，开发者...
leetcode卡-LeetCode---Arrays-and-Strings:LeetCode---数组和字符串
07-06
尤其在面试准备过程中，LeetCode 的数组和字符串专题是必不可少的环节。这个压缩包“LeetCode---Arrays-and-Strings”很可能是包含了一些关于数组和字符串问题的解决方案或练习题目。 数组和字符串是计算机科学中最...
Java统计一个字符串在另外一个字符串出现次数的方法
08-27
Java字符串遍历是指将字符串转换为字符数组，然后遍历数组以达到统计目的。在本文的getCount方法中，使用了substring方法将源字符串分割成多个子字符串，然后使用indexOf方法判断子字符串是否包含目标字符串，如果...
Java实现的简单字符串反转操作示例
08-27
本站专题《Java字符与字符串操作技巧总结》、《Java数组操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》等文章中都有详细的介绍。 Java中的字符串反转操作...
常微分方程算法之编程示例六-解一阶方程组（龙格-库塔法）
欢迎各位大佬光临“寒舍”！请多多指点，共同进步！
06-27 357
主要对本专栏介绍的常微分方程差分格式进行算例补充。
代码随想录-二叉搜索树①
希希雾里
06-30 519
代码随想录-二叉搜索树①
[Mdp] lc 494. 目标和(01背包变种+dp+dfs)
Y-puyu 的博客
06-30 318
【代码】[Mdp] lc 494. 目标和(01背包变种+dp+dfs)
代码随想录算法训练营第52天（py）| 动态规划 | 647. 回文子串、516.最长回文子序列
uncle_tou的博客
06-28 439
给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。
代码随想录算法跟练 | Day16 | 二叉树 Part03
weixin_59271089的博客
06-30 398
的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。本题也是简单题，通过递归返回所有左叶子节点的值即可，但需要注意，虽然是返回左节点的值，依然需要对右节点进行遍历，右节点有可能也存在左叶子节点。题目中平衡二叉树指左右子树最大深度差不超过 1，因此按之前的思路，求出树的最大深度和最小深度，最后判断差值绝对值是否小于等于 1 即可。，返回所有从根节点到叶子节点的路径。是指没有子节点的节点。，求出该树的节点个数。
力扣503
weixin_63680330的博客
06-27 297
给定一个循环数组nums的下一个元素是nums[0]），返回 nums中每个元素的。数字x的是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出-1。[2,-1,2]第一个 1 的下一个更大的数是 2；数字 2 找不到下一个更大的数；第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
Codeforces 220B
幼儿园大哥~
06-30 470
传送门 题目大意 给出一个长度为nnn的序列，进行mmm次询问。 每次询问区间[l,r][l,r][l,r]内，有多少个数字xxx刚好出现了xxx次。 思路 枚举右端点rrr，维护左端点lll，设法将sum(l,r)s u m ( l , r )sum(l,r) 表示为区间内的合法数字个数 所以以区间[2,2,2,2][ 2 , 2 , 2 , 2 ][2,2,2,2]为例： r=1r = 1r=1,左端点的贡献分别为:[0,0,0,0][ 0 , 0 , 0 , 0 ][0,0,0,0]; r=2r =
Sentinel 采用的是什么限流算法？
最新发布
2401_84419325的博客
07-01 1022
Sentinel 是阿里巴巴开源的一款流量控制和服务保护组件，旨在解决分布式系统中的流量管理、熔断降级、系统负载保护等问题。它提供了实时的流量监控、熔断降级、系统自适应保护等功能，能够帮助开发者有效管理和保护各种规模的应用服务。
14 卡尔曼滤波及代码实现
qq_44175983的博客
06-29 1010
卡尔曼滤波是一种利用线性系统状态方程，通过系统输入输出观测数据，对系统状态进行最优估计的算法。由于观测数据包括系统中的噪声和干扰的影响，所以最优估计也可看作是滤波过程。预测是根据上一时刻的状态量，由状态方程预测出下一时刻的状态量。加入观测，对预测值进行更新校正，得到最优后验估计。，以及状态量误差协方差的先验估计矩阵。以雷达追踪目标为背景，系统的状态方程为。是过程噪声，服从高斯分布，时刻的预测值，结合第。时刻的观测值，得到第。是上一时刻的最优估计。是过程噪声的协方差，是观测噪声的协方差。这是没有加观测值的。
最长字符串（指针专题
06-12
在指针专题中，"最长字符串"通常指的是在一个数组或动态分配的内存中找到最长的连续字符子串，这个子串可能是由任意类型的字符组成，比如字符数组、字符指针等。这里我们可以通过遍历数组，同时维护两个变量，一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值