数组与字符串专题

已于 2024-06-12 13:40:56 修改
阅读量202 收藏
点赞数 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_74706405的博客
02-27 227
数组的方法与总结
C#实现char字符数组与字符串相互转换的方法
08-31
本篇文章将详细阐述C#中实现char字符数组与字符串相互转换的方法。 一、字符串转换为字符数组 当你有一个字符串（string）并且需要将其分解为单个字符以便处理时，可以使用`ToCharArray()`方法。这个方法会将整个...
数组与字符串总结
m0_46335449的博客
12-01 852
重点：多维数组转化为一维数组公式，以及特殊矩阵的存储，还有字符串匹配算法
数组与字符串方法总结
m0_69068349的博客
02-26 460
数组与字符串方法总结
数组和字符串的常用方法总结
xy2041622796的博客
02-26 1161
数组和字符串的常用方法总结
C语言基础知识梳理（二）数组和字符串专题
qq_46485137的博客
10-06 687
1）数组定义的基本格式：数据类型数组名[元素个数]={值1, 值2, 值3}；数组名不仅表示该数组的名字，还可以表示该数组的首地址，这种给所有元素都复制，称为“完全初始化”，这个时候，[ ]里的元素个数可以省略。2）如果定义数组的时候，{ }中的数值个数
php 字符串转换数组,PHP数组与字符串相互转换
weixin_42295528的博客
03-09 611
PHP数组与字符串相互转换字符串与数组的转换在程序开发过程中经常使用，PHP 主要使用 explode()函数和 implode()函数实现，下面我们分别进行详细讲解。1.使用 explode()函数将字符串转换成数组explode()函数将字符串依指定的字符串或者字符(separator)切开。语法格式如下;array explode(string separator,string string...
c语言中的字符数组与字符串
bnmqwe1的博客
07-07 298
1、字符数组的定义与初始化 字符数组的初始化，最容易理解的方式就是逐个字符赋给数组中各元素。 char str[10]={ ‘I’,’ ‘,‘a’,‘m’,’ ‘,‘h’,‘a’,‘p’,‘p’,‘y’}; 即把10个字符分别赋给str[0]到str[9]10个元素 如果花括号中提供的字符个数大于数组长度，则按语法错误处理；若小于数组长度，则只将这些字符数组中前面那些元素，其余的元素自动定为空字符（即 ‘\0’ )。 2、字符数组与字符串 在c语言中，将字符串作为字符数组来处理。（c++中不是） 在实际应用
LeetCode/Java刷题----数组及字符串专题
qq_43621439的博客
07-10 320
Java刷题，数组及字符串专题
[java] 数组，字符串专题
浅夜
03-09 118
题目 5. 最长回文子串(动态规划) 151. 翻转字符串里的单词(collections,split,reverse,join) tips 集合、列表和数组 集合里的元素类型不一定相同，集合里的元素没有顺序 列表有顺序 数组有索引；java里数组里的元素类型必须相同；数组中的元素在内存中是连续存储的，且每个元素占用相同大小的内存 字符串 对于不同的编程语言中，字符串可能是可变的，也可能是不可变的。不可变意味着一旦字符串被初始化，你就无法改变它的内容。 在某些语言（如 C ++）中，字符串是可变的。
LeetCode腾讯算法篇之数组与字符串（一）
云瀚的自习室
10-28 603
LeetCode腾讯专题介绍：鹅厂是一家能让你拥有多元化职业发展的平台。尊重个性、轻松自在的工作环境、有趣的互联网工作。在鹅厂这家拥有海量用户基础的公司工作，能得到互联网应用最前沿的视野、获得好的专家辅导。小伙伴们是否早已心动，想要成为鹅厂的一员呢？别着急，今天我们就来帮助大家做好准备，或许就能成为未来一名优秀的鹅厂工程师。 下面开整LeetCode腾讯算法专题吧！ ...
字符串专题文档
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中的字符串反转操作...
算法-KMP字符串匹配
xx_xb的博客
07-23 124
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 628
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 713
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 296
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
最长字符串（指针专题
06-12
在指针专题中，"最长字符串"通常指的是在一个数组或动态分配的内存中找到最长的连续字符子串，这个子串可能是由任意类型的字符组成，比如字符数组、字符指针等。这里我们可以通过遍历数组，同时维护两个变量，一个记录当前已知的最长字符串长度，另一个记录当前正在处理的字符串的起始位置。 实现方法可以分为以下几个步骤： 1. 初始化两个变量：`max_len`为0，`start`为-1，用于存储最长字符串的信息。 2. 遍历数组，对于每个元素，检查它是否是新开始的字符串： a. 如果是新字符，将`start`更新为当前索引。 b. 如果不是新字符，计算从`start`到当前索引的子串长度，并与`max_len`比较： - 如果长度大于`max_len`，更新`max_len`和`start`。 3. 最后，返回从`start`到`start + max_len - 1`范围内的子串，即为最长的字符串。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值