文章目录
- 1、头文件
- 2、输入多组数据（未知长度）
- 3、常见的输出方式
- （1）整体输出
- （2）反向输出
- （3）控制输出精确度
- （4）输出后面无空格(vector)
- （5）list不能随机访问，可以转换为vector输出
- （6）可以先输出首元素，后面在输出元素前先加上空格
- 4、结构体入栈有几个注意事项
- 5、堆栈溢出的几个问题
- 6、关于返回值的问题：
- 7、runtime error可能的原因：
- 8、vector二维数组初始化：
- 9、string之unique(),erase(),remove()使用小记：
- 10、deque iterator not dereferencable 问题：
- 11、并不是所有迭代器都有加减法：
- 12、next_permutation()的用法：
- 1、生成全排列
- 2、生成某个序列后的第k个排列
- 13、STL常用算法：
- （1）sort
- （2）unique
- （3）string相关的操作
- （4）remove和erase移除元素
- （5）序列反转reverse
- （6）序列交换swap
- （7）统计等于某值的容器元素个数count
- （8）条件统计count_if
- （9）查找容器元素find
- （10）条件查找容器元素find_if
- （11）子序列搜索search
- （12）最后一个子序列搜索find_end
- （13）元素复制copy
- （14）元素变换transform
- （15）替换replace
- （16）条件替换replace_if
- （17）n次填充fill_n
- （18）随机生成n个元素generate
- （19）操作容器中的每一个元素for_each
- （20）条件移除remove_if
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);