力扣面试经典150题数组/字符串（简单）题解

简单题：
88.合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

 int i=m-1;
 int j=n-1;
 int k=m+n-1;
 while(i>=0&&j>=0)
{
  if(nums1[i]>nums2[j])
  {
  nums1[k]=nums1[i];
  i--;
  }
  else
  {
  nums1[k]=nums2[j];
  j--;
  }
  k--;
}
while(j>=0)
{
nums1[k]=nums2[j];
j--;
k--;
}

27.移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
返回 k。

int k=0;
for(int i=0;i<nums.size();i++)
{
if(nums[i]!=val)
{
nums[k]=nums[i];
k++;
}
else
{
contimue;
}
}
return k;

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

给你一个 非严格递增排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次 ，返回删除后数组的新长度。元素的相对顺序应该保持 一致 。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
返回 k 。

for(int i=0;k<nums.size();k++)
{
if(nums[i]!=nums[i+1])
{
nums[k]=nums[i];
i++;
}
else
{
i++;
}
}
return k;

169.多数元素

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。

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

121.买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

if(prices.size()==0||prices.size()==1)
        {
            return 0;
        }
        int minPrice=prices[0];
        int maxProfit=0;
        for(int i=1;i<prices.size();++i)
        {
            if(prices[i]<minPrice)
            {
                minPrice=prices[i];
            }
            else
            {
                int profit=prices[i]-minPrice;
                maxProfit=std::max(maxProfit,profit);
            }
        }
        return maxProfit;
    }

13.罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。
通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。

std::unordered_map<char,int>romanValues={
            {'I',1},{'V',5},{'X',10},{'L',50},
            {'C',100},{'D',500},{'M',1000}
        };
        int total=0;
        int preValue=0;
        for(int i=s.length()-1;i>=0;--i)
        {
            char currentChar=s[i];
            int currentValue = romanValues[currentChar];

        if (currentValue < preValue) 
        {
            total -= currentValue;
        } 
        else 
        {
            total += currentValue;
        }
        preValue = currentValue;
    }
    return total; // 返回最终的整数值
    }

58.最后一个单层词的长度

给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。

int count=0;
        bool foundword=false;
        for(int i=s.size()-1;i>=0;--i)
        {
            if(s[i]==' '&& !foundword)
            {
                continue;
            }
            if(s[i]!=' ')
            {
                foundword=true;
                count=count+1;
            }
            else if(s[i]=' ')
            {
                break;
            }
        }
        return count;

14.最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。
如果不存在公共前缀，返回空字符串 “”。

const std::string& firstStr = strs[0];
    int prefixLength = firstStr.length();
    for (size_t i = 1; i < strs.size(); ++i) {
        const std::string& currentStr = strs[i];
        prefixLength = std::min(prefixLength, static_cast<int>(currentStr.length()));
        for (int j = 0; j < prefixLength; ++j) {
            if (firstStr[j] != currentStr[j]) {
                prefixLength = j; 
                break; 
            }
        }
        if (prefixLength == 0) {
            return "";
        }
    }
    return firstStr.substr(0, prefixLength);
    }

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

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。

size_t position = haystack.find(needle);   
    // 如果找到，返回位置；否则返回 -1
return (position != std::string::npos) ? static_cast<int>(position) :-1;