平时刷题遇到的一些常见问题

置顶 于 2018-05-26 10:52:48 发布
阅读量772 收藏 5
点赞数 2
分类专栏： # 刷题知识积累 文章标签： 刷题 输入输出 unique runtime error
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daaikuaichuan/article/details/80459920
版权

文章目录

1、头文件

#include <bits/stdc++.h>
using namespace std;
void run()  
{  
      
}  
void local_test()  
{  
    system("notepad d:\\input.txt");  
    freopen("d:\\input.txt","r",stdin);  
}  
int main()  
{  
    //local_test();  
    run();  
    return 0;  
}

2、输入多组数据（未知长度）

char ch;
int tmp;
vector<int> data;
while ((ch = cin.get()) != '\n') {
	cin.unget();
	cin >> tmp;
	data.push_back(tmp);
}

3、常见的输出方式

（1）整体输出

for (const auto s : vec)
{
	cout << s << endl;
}

（2）反向输出

for (auto s=vec.rbegin() ; s!=vec.rend() ; ++s)
	cout << *s;

（3）控制输出精确度

for (auto s : a)
	count += s;
cout.setf(ios::fixed);  
cout << fixed << setprecision(2) << count <<endl;//精度保留2位小数。

（4）输出后面无空格(vector)

for (j = vec.begin() ; j != (vec.end()-1) ; ++j)
	cout << *j << " ";
cout << *(vec.end()-1) << endl;

（5）list不能随机访问，可以转换为vector输出

v_str vec_str(lst_str.begin(),lst_str.end());//迭代器初始化。
if(!vec_str.empty())
{
	auto it = vec_str.begin();
	while(it != (vec_str.end()-1))。
	{
		cout << *it++ << " " ;
	}
	cout << *(vec_str.end()-1);
}

（6）可以先输出首元素，后面在输出元素前先加上空格

if(!lst_str.empty())
{
	auto it = lst_str.begin();
	cout << *it++;
	while(it != (lst_str.end()))
	{
		cout << " " << *it++;
	}
}

4、结构体入栈有几个注意事项

（1）类型要使用结构体名；

（2）入栈的是结构体对象；

（3）入栈的时候不能传引用，如果想更新数据，可以在弹栈的时候赋值更新元素。

5、堆栈溢出的几个问题

（1）vector如果要随机访问进行赋值，则必须先分配空间；

（2）局部数组不能太太，否则会产生堆栈溢出；可以使用全局数组或者动态分配。

（3）可以使用long long int防止数据太小导致的问题；

6、关于返回值的问题：

  每一个条件判断分支都要返回值，不然会报错，递归问题尤其要注意：

//把输入数据不断按位求和直到最终数据为个位数。
int fun(string str)
{
	int	sum = 0;
	for (int i = 0; i < str.size(); ++i)
	{
		sum += str[i] - '0';
	}
	if (sum < 10)
		return sum;
	return fun(to_string(sum));//必须要返回。
}

7、runtime error可能的原因：

  • 除以零；
  • 数组越界：int a[3]; a[10000000]=10;
  • 指针越界：int * p; p=(int *)malloc(5 * sizeof(int)); *(p+1000000)=10;
  • 使用已经释放的空间：int * p; p=(int *)malloc(5 * sizeof(int));free(p); *p=10;
  • 数组开得太大，超出了栈的范围，造成栈溢出。
//有的时候再出现这样的错误还会给提示

Runtime Error(ARRAY_BOUNDS_EXCEEDED) // array bounds exceed 数组越界

Runtime Error(DIVIDE_BY_ZERO) //divisor is nil   除零

Runtime Error(ACCESS_VIOLATION) //illegal memory access   非法内存读取

Runtime Error(STACK_OVERFLOW) //stack overflow        堆栈溢出

8、vector二维数组初始化：

vector<vector<int>> v;
v.resize(r, vector<int>(c, 0)); // 一次指定内外层vector大小,并初始化为0。

9、string之unique(),erase(),remove()使用小记：

  uniqe()函数是去掉重复的字符。是只两个相同的字符**连续出现**就只留下一个，其余的就删除。

string s("hello,world");
string::iterator iterEnd=unique(s.begin(),s.end());

  这代码执行后，s的值为helo,worldd. 只消除连续出现的同样的字符。不连续的不消除。 还有一个就是unqiue()函数删除重复的字符后，字符串长度不变，所以如果字符串删除字符后，后面按照之前的值填上。 所以就是helo,worldd，而不是helo,world；所以就会有一个函数erase()函数存在的必要性了。它可以删除字符。s.erase(iterEnd,s.end());一般都是结合使用：

#include <algorithm>
#include <string>
// 去除连续的元素
s.erase(unique(s.begin(), s.end()), s.end()); 
// 去除指定的元素（字符串中所有该元素）
s.erase(remove(s.begin(), s.end(), '0'),s.end()); 
// 去除首元素
s.erase(0, 1);

10、deque iterator not dereferencable 问题：

  出现这种问题一般是访问某一个不存在的位置：

#include <iostream>
#include <queue> 
using namespace std; 
int main()
{	
	queue<int> x;		
	for(int i = 0;i < 10;i++)
	{		
		x.push(i+1);
	}		
	while(!x.empty())
	{		
		cout << x.front() << " ";		
		x.pop();	
		x.push(x.front()); // pop()之后一定要检查队列是否为空。
		x.pop();	
	}	
	cout << endl; 
	return 0;
}

11、并不是所有迭代器都有加减法：

  能进行算术运算的迭代器只有随机访问迭代器，要求容器元素存储在连续内存空间里，vector，string，deque的迭代器是有加减法的，但是map，set，multimap,multiset的迭代器是没有加减法的，list也不可以 。

12、next_permutation()的用法：

  STL提供了两个用来计算排列组合关系的算法，分别是next_permutation和prev_permutation。首先我们必须了解什么是“下一个”排列组合，什么是“前一个”排列组合。考虑三个字符所组成的序列{a,b,c}。这个序列有六个可能的排列组合：abc，acb，bac，bca，cab，cba。
  next_permutation()会取得[first,last)所标示之序列的下一个排列组合，如果没有下一个排列组合，便返回false;否则返回true。

1、生成全排列

#include <algorithm>
#include <iostream>
#include <string.h>
using namespace std;

int main()
{
    char a[3]={'a','b','c'};
    for(int i=1; i<=6; i++)  
    {
        for(int j=0; j<3; j++)
            cout << a[j] << " ";
        cout << endl;
        //放在第一个排列的后边，输出第一个排列的下一个排列。
        next_permutation(a, a+3);
    }
    return 0;
}

2、生成某个序列后的第k个排列

#include <bits/stdc++.h>
using namespace std;
int main()
{
    int n, k;
    while (cin >> n >> k)
    {
        vector<int> nums(n);
        for (int i = 0; i < n; ++i) 
            cin >> nums[i];
        while (k > 0)
        {
            k--;
            // 输出下一个排列
            next_permutation(nums.begin(), nums.end());
        }
        for (int i = 0; i < n - 1; ++i) 
            cout << nums[i] << " ";
        cout << nums[n - 1] << endl;
    }
    return 0;
}

13、STL常用算法：

（1）sort

sort(v.begin(),v.end());

（2）unique

auto end_unique = unique(begin(vec1), end(vec1));
// 去掉连续重复的元素。
vec1.erase(end_unique,vec1.end());

（3）string相关的操作

char c = 'a';  
string str(1, c);//一个字符转换成string
 
string str = to_string(i);//整型数转换为string。
 
int i = stoi(str);//string转换为整型值。
 
str2.append(str);//追加字符串。
 
str2.resize(str2.size()+d,'0');//通过resize将字符串高位补d个零。
 
string str2 = str.substr(j,cnt);//构造字符串：在str字符串中从j位置开始的cnt个字符。
 
string(f,end(str));//构造字符串：在str字符串中从f位置开始到某个结束位置的所有字符。
 
bool fun(string s, unordered_set<string> &dict)
{
    for (const auto d : dict)
    {
        auto m = s.find(d);//在字符串s中找子串d, 返回起点下标
        if (m != string::npos)//如果查找成功则删除子串, 起点和d的长度 
            s.erase(m, d.size());
        }
    }
}
 
// 判断一个字符串是否包含另一个子串（不一定是连续）
bool isequal(string str1, string str2)
{
    int i = 0, j = 0;
    int sz1 = str1.size();
    int sz2 = str2.size();
    while (i < sz1 && j < sz2){
        if (str2[j] == str1[i])
            j++;
        i++;
    }
    if (j == sz2)
        return true;
    else
        return false;
}
 
// erase函数有3种用法： 
// 删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符 
str.erase(pos,n);
// 删除pos处的一个字符(pos是个string类型的迭代器) 
str.erase(pos);
// 删除从first到last之间的字符（first和last都是迭代器） 
str.erase(first,last);

int index = str.find_first_not_of('0'); // 返回第一个不为零的位置

// 字符串分割：
// strin是输入字符串，delim是用来分割的字符，要包含头文件regex
vector<string> Split(const string& strin, const string& delim)
{
	regex re{ delim };
	return vector<string>{ sregex_token_iterator(
							strin.begin(), strin.end(), re, -1), 
							sregex_token_iterator() };
}

// 字符串去掉所有空格
void deleteAllMark(string &s, const string &mark)
{
	int nSize = mark.size();
	while(1)
	{
		int pos = s.find(mark);
		if(pos == string::npos)
		{
			return;
		}
		s.erase(pos, nSize);
	}
}

// 按空格分割字符串
int sz = str.size(), j = 0;
for (int i = 0; i <= sz; ++i) {
    if (i == sz || str_in[i] == ',') {
    	string str_tmp = str_in.substr(j, i-j);
    	j = i + 1;
	}
}

（4）remove和erase移除元素

str.erase(remove(str.begin(), str.end(), '*'), str.end());

（5）序列反转reverse

reverse(begin(str1), end(str1)); //字符串反转。

（6）序列交换swap

swap(str1, str2);//交换两个字符串。

（7）统计等于某值的容器元素个数count

list<int> lst;
count(lst.begin()，lst.end()，value);

（8）条件统计count_if

count_if(vec.begin()，vec.end()，pred); // pred可以是函数也可以是lambda表达式

（9）查找容器元素find

// 它用于查找等于某值的元素。它在迭代器区间[first,last)(闭开区间)上查找
// 等于value值的元素，如果迭代器i所指的元素满足*i=value，
// 则返回迭代器i；未找到满足条件的元素，返回last。
find( vec.begin(), vec.end(), num_to_find);

（10）条件查找容器元素find_if

// 利用返回布尔值的谓词判断pred，检查迭代器区间[first,last)(闭开区间)上的每一个元素，
// 如果迭代器i满足pred（*i）＝true，表示找到元素并返回迭代值i（找到的第一个符合条件
// 的元素）；未找到元素，返回末位置last。
find_if(vec.begin(), vec.end(), pred);

（11）子序列搜索search

// 在[First1,last2)中查找[Frist2,last2)中序列，如果找到了就在[First1,last1)中
// 返回First1的迭代器对象，如果没有找到就返回last1。
iter = search(vec1.begin(), vec1.end(), vec2.begin(), vec2.end());

（12）最后一个子序列搜索find_end

// 在一个指定的元素序列里查找另一指定子序列最后一次出现的位置。
iter = find_end(vec1.begin(), vec1.end(), vec2.begin(), vec2.end());

（13）元素复制copy

// 将vec1中的元素复制到vec2中。
copy(vec1.begin(), vec1.end(),vec2.begin());

（14）元素变换transform

// 按某种方案将vec1中的元素复制到vec2中。
copy(vec1.begin(), vec1.end(),vec2.begin(), square);

（15）替换replace

// 用str替换 迭代器起始位置 到 结束位置 的字符 
// 将line从begin位置开始的6个字符替换成1
line=line.replace(line.begin(), line.begin()+6, "1");
// 用str替换指定字符串从起始位置pos开始长度为len的字符
// 将line中的第一个&替换成1
line=line.replace(line.find("&"), 1, "1");

（16）条件替换replace_if

// 把vector中所有奇数替换为0
replace_if (vec.begin(), vec.end(), IsOdd, 0);

（17）n次填充fill_n

// 在vec.begin的后面插入5个0。
fill_n(vec.begin(), 5, 0);

（18）随机生成n个元素generate

// 在vec.begin的后面插入5个10以内的随机数。
generate_n(vec.begin(), 5, [](){return rand()%10;);

（19）操作容器中的每一个元素for_each

for_each(vec.begin(), vec.end(), [](int i){cout << i << endl;});

（20）条件移除remove_if

// 返回值相当于移除满足条件的元素后形成的新向量的end()值。
remove_if(vec.begin(), vec.end(), pred);
~青萍之末~
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

~青萍之末~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值