博客围绕C++编程展开，介绍了数组大小获取、整数反转、整数转字符串等基础操作，还涉及栈的使用解决有效括号问题。同时给出多道算法题的思路与代码，如删除数组重复项、最大子序和、斐波那契数列等，包含相关函数使用及注意事项。
1、在c++中求一个数组a的大小用a.size()
2、32位有符号整数范围2^31-1=2147483647,-2^31=-2147483648
abs()函数用来取绝对值
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
class Solution {
public:
int reverse(int x) {
int y=0;
while(x!=0){
if(x>0 && y<=(INT_MAX-x%10)/10 || x<0 && y>=(INT_MIN-x%10)/10)
y=y*10 + x%10;
else
return 0;
x/=10;
}
return y;
}
};
3、c++中将整数转化为字符串需要头文件#include<string>，然后就可以直接使用string a=to_string(num)
访问字符串中的某个字符时直接按照数组方式访问，比如访问字符串a的第一个字符a[0]
4、size()函数返回的值类型为string::size_type
5、有效括号问题使用栈解决，思想是设置一个空栈，如果出现一对中的第二个符号直接把栈顶的符号推出
在使用栈的时候需要写头文件#include<stack> stack <栈类型> 栈名；
6、#21
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {} c++中的结构体相当于类，不过在结构体中所有成员都是默认public，但是类中成员都是默认private，这里就相当于定义了一个构造函数，并且给之前定义的变量val和next指针复制初始化
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
//新建一个头节点，用来存合并的链表。
ListNode* finallist = new ListNode(-1);
ListNode* f=finallist;
while(l1&&l2)
{
if(l1->val<l2->val)
{
f->next=l1;
l1=l1->next;
}
else
{
f->next=l2;
l2=l2->next;
}
f=f->next;
}
if(l1)
f->next=l1;
else
f->next=l2;
return finallist->next;
}
};
7、删除数组中的重复项#26
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int len=nums.size();
if(len==0)
return 0;
int i=0,j=i+1;
while(j<len)
{
if(nums[i]==nums[j])
j++;
else
{
nums[i+1]=nums[j];
j++;
i++;
}
}
return i+1;
}
};
8、移除元素
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int len= nums.size();
if(len==0)
return 0;
int i=0;
while(i<len)
{
if(nums[i]==val)
{
nums[i]=nums[len-1];
len--;
}
else
{
i++;
}
}
return len;
}
};
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
38题 报数
#include<iostream>
#include<string>
#include <cstring>
using namespace std;
class Solution {
public:
string countAndSay(int n) {
if(n==1)
return "1";
if(n==2)
return "11";
int count=0;
string str="11";
string now;
char f,d;
for(int i=3;i<=n;i++) //从第三个报数开始
{
f=str[0]; //此处的意思是假如是要看第四次的报数 1211，那么在把第三次的报数统计完之后要重新给f赋值，f记录的就是要统计的最新的str的第一个数
for(int j=0;j<str.size();j++) //从该字符串的第一个字符开始进行处理比对
{
if(str[j]==f) //一般情况下第一次肯定是符合该分支的条件，count用来记录有几个相同的数，d用来记录这个数的数值
{
count++;
d=str[j];
}
else
{
//cout<<count<<endl;
now=now+to_string(count)+d; //如果相同的数记录玩之后，记录下一个数就得先把之前的数记录下来
//cout<<now<<endl;
f=str[j]; //重新给f赋值进行比对
j--; //因为你重新比对的是当前的值，如果不j--的话就会把当前的数字忽略，所以先要j--，从当前的值进行重新的比对
count=0; //count要记为0,
}
}
str=now+to_string(count)+d; //此处的含义是，比如我们是第四次报数，但是我们是从第三次开始进行这些报数操作的，那么这块就是对第三次数据处理的结果，如果是5次报数，那么就是第三次第四次数据报数的结果以此类推
now=""; //对于now和count都得记零，这样才能进行下一次的报数
count=0;
}
return str;
}
};
int main()
{
Solution s;
cout<<s.countAndSay(6)<<endl;
}
53、最大子序和
这道题其实不难，只是求出最大子序和，那就是只要遇到负数就直接赋值，用两个变量来记录和，一个进行操作，一个值进行比较
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int len=nums.size();
int i;
int sum=nums[0];
int fin=nums[0];
for(i=1;i<len;i++)
{
if(sum<0)
sum=nums[i];
else
sum=sum+nums[i];
if(sum>fin)
fin=sum;
}
return fin;
}
};
58、
class Solution {
public:
int lengthOfLastWord(string s) {
int f=0;
int count=0;
int len=s.size();
for(int i=0;i<len;i++)
{
if(s[i]==' ')
count++;
}
cout<<count<<endl;
if(count==len)
return 0;
else
{
cout<<"*"<<endl;
for(int k=0;k<len;k++)
{
cout<<"**"<<endl;
if(s[k]==' ')
{
cout<<k<<endl;
for(int j=f;j<=k;j++)
s.erase(0,1);
cout<<s<<endl;
}
}
}
return s.size();
}
};
class Solution {
public:
int lengthOfLastWord(string s) {
if(s.empty()) return 0;
int count = 0;
for(int n = s.size() - 1; n >= 0; n--){
if(s[n] == ' '){
if(count == 0) continue; // 跳过最后面的空格
else break;
}
else
count++;
}
return count;
}
};
erase函数用来删除数组或者字符串中的元素，具体用法比如要删除字符串s中的第一个元素s.erase(0,1)
66、
class Solution {
public:
vector<int> plusOne(vector<int>& digits) {
int i;
int len=digits.size();
int flag=0;
if(digits[len-1]<9)
digits[len-1]+=1;
else
{
digits[len-1]=0;
for(i=len-2;i>=0;i--)
{
if(digits[i]<9)
{
if(flag==0)
{
digits[i]+=1;
break;
}
else
{
if(digits[i]<9)
{
digits[i]+=1;
break;
}
else
{
digits[i]=0;
flag=1;
}
}
}
else
{
digits[i]=0;
flag=1;
}
}
}
if(digits[0]==0)
digits.insert(digits.begin(),1);
return digits;
}
};
我自己做出来的一道题，但是代码写的不怎么样
1、向数组中插入元素用insert()函数
2、end（）和begin（）分别是数组最后一个位置和第一个位置
67、二进制求和
我的方法：
class Solution {
public:
string addBinary(string a, string b) {
int aa=0,bb=0,suma=0,sumb=0,sum=0,num;
string c="";
for(int i=a.size()-1;i>=0;i--)
{
if(a[i]=='0')
{
aa++;
continue;
}
else
{
suma+=pow(2,aa);
aa++;
}
}
for(int j=b.size()-1;j>=0;j--)
{
if(b[j]=='0')
{
bb++;
continue;
}
else
{
sumb+=pow(2,bb);
bb++;
}
}
sum=suma+sumb;
while(sum)
{
num=sum%2;
sum=sum/2;
c=to_string(num)+c;
}
return c;
}
};
其中c++中求几次方使用pow（）函数，比如2的3次方pow（2,3）
还有就是字符串头部尾部增加字符支付要直接相加就好，而且整数需要转格式用to_string
class Solution {
public:
string addBinary(string a, string b) {
int p = a.size() - 1;
int q = b.size() - 1;
int renter = 0, sum = 0;
string ret;
while (p >= 0 || q >= 0) {
int a1 = p >= 0 ? a[p--] - '0' : 0;
int b1 = q >= 0 ? b[q--] - '0' : 0;
sum = a1 + b1 + renter;
// 这里注意不能用ret += to_string，因为顺序是反着的。先算的需要放最后面。
ret = to_string(sum % 2) + ret;
renter = sum / 2;
}
return renter == 1 ? "1" + ret : ret;
}
};
改天自己再写写
69、x的平方根
class Solution {
public:
int mySqrt(int x) {
long int result=0,compar=0;
for(int i=1;i<=x;i++)
{
result=pow(i,2);
if(result<x)
{
compar=result;
continue;
}
else if(result==x)
return i;
else
return i-1;
}
return 0;
}
在写这段代码的时候，出现了溢出的问题，因此定义result以及compar的时候要使用long int来定义
70、斐波那契数列——爬楼梯
class Solution {
public:
int climbStairs(int n) {
int a[1000] = {0} , i;
a[1] = 1;
a[2] = 2;
for(i = 3; i <= n; i++)
a[i] = a[i - 1] + a[i - 2];
return a[n];
}
};
该数列的特征是第三项是前两项之和
扫一扫
1035
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
