LeetCode题（01，09,13,14,27,28,58）--《c++》

1.两数之和

//
// Created by wxj05 on 2024/7/18.
//
//暴力（n*2）
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for(int i=0;i<nums.size();i++){
            for(int j=i+1;j<nums.size();j++){
                if(nums[i]+nums[j]==target){
                    return {i,j};
                }
            }
        }
        return {};
    }
};

暴力求解方法：
使用两层循环遍历向量中的每对数字组合。
外层循环（变量i）从0到nums.size()-1。
内层循环（变量j）从i+1到nums.size()-1，这样可以避免重复检查同一对数字和自我匹配。
在内层循环中，检查当前的nums[i]和nums[j]之和是否等于target。
如果相等，则立即返回一个向量包含i和j作为结果。
如果循环结束后都没有找到符合条件的数对，则返回一个空向量。
时间复杂度：O(n^2)，其中n是nums的长度。因为每个元素都要和其他所有元素进行比较。
空间复杂度：O(1)，除了输入和输出外，只使用了常数级别的额外空间。

09.回文数

//
// Created by wxj05 on 2024/7/18.
//
class Solution {
public:
    bool isPalindrome(int x) {
        if(x<0){
            return false;
        }else{
            string b=to_string(x);
            int left=0,right=b.length()-1;
            while(left<right){
                if(b[left]!=b[right]){
                    return false;
                }
                left++;
                right--;
            }
            return true;
        }
    }
};

 逻辑流程：
首先，检查x是否小于0。由于负数不能是回文数，因此如果x小于0，函数立即返回false。
然后，将整数x转换为字符串b。这一步利用了to_string()函数，它能将整数转换为其对应的字符串表示。
初始化两个指针left和right，分别指向字符串b的开始和结束位置。
进入一个while循环，只要left小于right，就继续执行以下操作：
比较b[left]和b[right]，如果它们不相等，说明x不是回文数，函数返回false。
否则，将left加1，right减1，继续比较下一个字符对。
如果整个循环完成没有发现不匹配的字符对，那么x是回文数，函数返回true。
时间与空间复杂度：
时间复杂度：O(n)，其中n是数字x的位数。这是因为需要遍历字符串b的一半长度来检查是否为回文。
空间复杂度：O(n)，这是由于创建了字符串b，其长度与数字x的位数相同。

13.罗马数字转整数

//
// Created by wxj05 on 2024/7/18.
//
class Solution {
public:
    int romanToInt(string s) {
        int n=0;
        int sum=0;
        int m=0;
        for(int i=s.size()-1;i>=0;i--){
            if(s[i]=='I') n=1;
            else if(s[i]=='V') n=5;
            else if(s[i]=='X') n=10;
            else if(s[i]=='L') n=50;
            else if(s[i]=='C') n=100;
            else if(s[i]=='D') n=500;
            else if(s[i]=='M') n=1000;

            if(n>=m){
                sum+=n;
                m=n;
            }
            else{
                sum-=n;
                m=n;
            }

        }
        return sum;
    }
};

 逻辑流程：
初始化三个整型变量n、sum和m，分别用于存储当前字符对应的数值、总和以及前一个字符的数值。
从字符串s的末尾开始遍历，即从右至左。
对于每一个字符，根据其罗马数字的值设置n。
检查n是否大于或等于m：
如果是，将n加到sum上，并更新m为当前的n。
如果否，从sum中减去n，并同样更新m为当前的n。
完成循环后，返回sum作为最终的整数值。
时间与空间复杂度：
时间复杂度：O(n)，其中n是罗马数字字符串的长度。这是因为算法需要遍历整个字符串一次。
空间复杂度：O(1)，因为使用的额外空间（几个变量）是固定的，与输入字符串的大小无关。

14.最长公共前缀

//
// Created by wxj05 on 2024/7/18.
//
class Solution {
public:
    string longestCommonPrefix(vector<string>& strs) {
        int count=0;
        string str1=strs[0];
        for(int i=0;i<str1.size();i++){
            char s=str1[count];//比较的字母
            int flag=1;//标记
            for(int j=0;j<strs.size();j++){
                if(strs[j][i]!=s){
                    flag=0;
                    break;
                }
            }
            if(flag==0) break;
            count++;
        }
        return str1.substr(0,count);
    }
};

 逻辑流程：
初始化一个计数器count，用于记录公共前缀的长度。
假设第一个字符串str1为基准字符串，用于比较。
从str1的第一个字符开始，逐个字符地检查它是否在所有字符串中都出现于相同的位置。
对于str1中的每一个字符i：
将str1中的当前字符赋值给s。
初始化一个标志变量flag为1，表示当前字符在所有字符串中都匹配。
遍历strs中的每一个字符串j：
如果strs[j]在相同位置的字符不等于s，则设置flag为0，并跳出内层循环。
如果flag仍为1，说明当前字符在所有字符串中都是公共的，增加count。
如果flag为0，表示发现了不匹配的字符，跳出外层循环。
最终，使用substr函数从str1中截取出从开头到count位置的子串，作为最长公共前缀返回。

27.移除元素

//
// Created by wxj05 on 2024/7/18.
//
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int k=0;
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=val){
                nums[k]=nums[i];
                k++;
            }
        }
        return k;
    }
};

 逻辑步骤:
初始化一个变量k为0，用来记录新数组的有效长度（即不含val的元素个数）。
使用一个for循环遍历整个向量nums。
对于数组中的每个元素，如果当前元素nums[i]不等于待移除的值val:
则将其复制到向量nums的k位置（即新的有效区域内）。
然后增加k的值，表示已找到一个有效元素。
如果当前元素等于val，则忽略它，继续检查下一个元素。
循环结束后，k即为数组中不等于val的元素数量，返回k作为结果。
时间与空间复杂度：
时间复杂度: O(n)，其中n是nums向量的长度。需要遍历整个向量一次。
空间复杂度: O(1)，没有使用额外的数据结构，原地修改输入向量。

 28.找出字符串中第一个匹配项的下标

//
// Created by wxj05 on 2024/7/18.
//
class Solution {
public:
    int strStr(string haystack, string needle) {
        return haystack.find(needle);
    }
};

逻辑流程：
函数直接调用了haystack字符串对象的成员函数find，传入needle作为参数。
find函数会返回needle在haystack中的起始位置，如果needle不存在于haystack中，则返回string::npos，这是一个表示找不到的特殊值，通常等于-1。
时间与空间复杂度：
时间复杂度：通常情况下，find函数的时间复杂度为O(m*n)，其中m是haystack的长度，n是needle的长度。但在现代C++标准库中，find的实现可能使用了更高效的算法，如KMP算法，其时间复杂度为O(m + n)。
空间复杂度：O(1)，除了输入和输出外，这个函数没有使用额外的空间。 

58.最后一个单词的长度

//
// Solution 类用于解决计算字符串最后一个单词的长度问题。
//
class Solution {
public:
    /**
     * 计算字符串 s 中最后一个单词的长度。
     *
     * @param s 输入的字符串，可能包含空格和多个单词。
     * @return 返回最后一个单词的长度。
     */
    int lengthOfLastWord(string s) {
        // 移除字符串末尾的空格，以便准确找到最后一个单词的末尾。
        s.erase(s.find_last_not_of(' ') + 1); // 去掉末尾空格

        // 获取处理后字符串的末尾位置。
        int end = s.size() - 1;

        // 找到倒数第二个空格的位置，即最后一个单词的开始位置。
        int start = s.find_last_of(' ', end - 1); // 找到最后一个空格的位置

        // 如果字符串中没有空格，说明只有一个单词，直接返回字符串长度。
        // 如果没有空格，整个字符串就是一个单词
        if (start == string::npos) {
            return s.size();
        }

        // 返回最后一个单词的长度。
        return end - start;
    }
};

 逻辑步骤：
去除末尾空格：首先，使用erase和find_last_not_of(' ')方法去除字符串末尾的空格。find_last_not_of(' ')找到最后一个不是空格的字符位置，然后+1是为了移除之后的空格，包括这个字符之后的所有空格。
定位最后一个单词：
计算处理后字符串的末尾索引end。
使用find_last_of(' ', end - 1)找到倒数第二个空格的位置，即最后一个单词的起始位置。如果字符串中没有空格，find_last_of会返回string::npos。
计算长度并返回：
如果start等于string::npos，说明字符串中没有空格，整个字符串就是一个单词，直接返回字符串的长度。
否则，返回最后一个单词的长度，即end索引减去start索引的差值。
时间与空间复杂度：
时间复杂度：O(n)，其中n是字符串s的长度。尽管使用了两次查找操作，但总体上每个字符最多被遍历一次。
空间复杂度：O(1)，因为虽然进行了字符串的修改，但是是就地修改，并未使用与原字符串长度成比例的额外空间。