本文详细介绍了C++标准模板库(STL)中的各种容器，包括vector、string、map、unordered_set等的使用方法，涵盖了创建、遍历、排序、查找、删除等常见操作，以及一些高级应用技巧。
创建一个m*n的二维vector
vector<int> col(n);
vector<vector<int> > res(m,col);
或者
vector<vector<int> > res(m,vector<int>(n));
vector<vector<int> > res(m,vector<int>(n,0));//初始赋值为0
vector<vector<int> > res(m,vector<int>(n,2));//初始全赋值为2
res[0][0]=1;
创建一个二维的vector并赋值
vector<int> temp;
vector<vector<int> > result;
int c = 100;
temp.push_back(c);
result.push_back(temp);
cout << result[0][0];//result[0]=temp;result[0][0]=temp[0]=100
vector<string> strs{ "flower" ,"flow" ,"flight" };//初始化赋值
vector<int> intnum{1,2,3 };
vector<int> intnum(4,3);//初始赋值intnum.size()=4,每个元素都为3
sort快速排序用法
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
bool great(int a, int b)
{
return a > b;
}
int main()
{
int a[8] = {1,3,2,4,7,6,5,9};
vector<int> temp{1,3,2,4,7,6,5,9};
sort(temp.begin(),temp.end());//默认从小到大排序,sort用在vector,默认 less<int>()
sort(a, a + 8, less<int>());//从小到大
sort(a, a + 8);//sort用在数组
sort(temp.begin(), temp.end(),great);//自定义从大到小排序函数great
sort(temp.begin(), temp.end(),greater<>());//系统从大到小排序函数greater
sort(a, a + 8,lesser);
for (auto i : a)
cout <<i << endl;
return 0;
}
断言函数assert,如果表达式值为假，则打印出错信息，然后终止程序运行
#include <assert.h>
int a = 1;
assert(a<0);//此时打印出错信息，然后终止程序运行
vector迭代器使用
#include <vector>
vector<int> vec;
for (vector<int>::iterator iter = vec.begin(); iter != vec.end(); ++iter)
{
cout << *iter <<endl;
}
for (auto iter = data.begin(); iter != data.end(); ++iter)
{
cout << *iter <<endl;
}
for(auto i:vec)
cout<<i<<endl;
partition函数，将整个数组分成满足条件的左边，和不满足条件的右边。
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool isodd(int i)
{
return i % 2 == 0;
//return i % 2 ==1;
}
int main()
{
vector<int> input;
int a[8] = { 1,3,2,4,7,6,5,9 };
for (int i = 0; i < 8; i++)
input.push_back(a[i]);
partition(input.begin(), input.end(), isodd);
for (auto i : input)
cout << i << " ";
return 0;
}
//cout:6 4 2 3 7 1 5 9
string，char [ ]与int转换
#include <string>
string str = "123";
int num = stoi(str);
string str1 = to_string(num);
char str[] = "123";
int num = stoi(str);
把char*转化为string:
char* str = "12ddac3-";
string str1;
int i = 0;
while (str[i] != '\0')
{
str1.push_back(str[i]);
i++;
}
substr函数，s.substr(i,j)获得字符串中从第i位开始的长度为j的字符串
string s("12345asdf");
string a = s.substr(1,5); //获得字符串s中从第1位开始的长度为5的字符串
cout << a << endl;//cout:2345a
从string和vector删除字符，erase函数
**方法一：使用iterator和erase(删除it处的一个字符）**
string s="hello world";
int pos = s.find_last_of(' ');//s=5
s.erase(pos);//传入int型的参数，默认删除从5开始的所有元素， s=“hello”
string::iterator pos1 = s.begin()+pos;
s.erase(pos1);//传入迭代器型的参数，只删除该位置处的元素，s="helloworld"
for (string::iterator it = s.begin(); it != s.end(); ++it)
{
if (*it == ' ')
{
s.erase(it); //删除it处的一个字符
break;
}
}//s="helloworld"
s.erase(2,3);//删除从下标2开始的3个字符；s="he world"
s.erase(s.find('w'), 3);//删除从‘w’开始的3个字符；s="hello ld",s.find('w')返回下标3
**方法二：使用remove（删除[begin,end)之间的所有值等于'a'的值.）**
s.erase(remove(s.begin(), s.end(), 'e'), s.end());//删除[begin,end)之间的所有等于'e'的值,s="hllo world"
s.erase(remove(s.begin()+5, s.end(), ' '), s.end());//s="helloword"
s.erase(remove(s.begin() , s.begin()+3, 'e'),s.end());//s="hl"
s.erase(remove(s.begin() , s.begin()+3, 'e'), s.begin() + 3);//s="hllo word"
s.erase(remove(s.begin() , s.begin()+3, ' '), s.begin() + 3);//s="hello word"
删除所有末尾的空格：
string s = "hello world www ";
int pos = s.find_last_not_of(' ');
s.erase(remove(s.begin()+pos, s.end(), ' '), s.end());
对vector的erase完全一样：
vector<int> vec{122,22,39};//删除某个位置元素
vector<int>::iterator iter = vec.begin()+1;
vec.erase(iter);// vec{122,39}
//删除值为某个数的元素
for (vector<int>::iterator iter = vec.begin(); iter != vec.end(); iter++)
{
if (*iter == 22)
{
vec.erase(iter);break; // vec{122,39}
}
}
//删除[begin,end)之间的所有值等于22的值.）
vector<int> vec{122,22,39,22};
vec.erase(remove(vec.begin(), vec.end(), 22), vec.end()); // vec{122,39}
vec.insert(v.begin(),8);//在vector最前面插入新元素。 vec{8,122,39}
v.insert(v.end(),3);//在向量末尾追加新元素。
insert的第一个参数是迭代器，向迭代器之前的位置插入元素
insert(vec.end(),a)==vec.push_back(a)
erase迭代器失效
问题，错误使用如下：
vector<int> nums{122,22,22,39};
for (vector<int>::iterator iter = nums.begin(); iter != nums.end();iter++)
{
if (*iter == 22) nums.erase(iter);
}
当执行了一次earse操作之后，原来用来遍历的iterator就失效了，其行为是不可预测的，具体情况由实现决定。同时earse操作会返回一个指向下一个元素的iterator，如果想继续遍历，就得用返回的iterator继续操作。
所以针对上面的代码，如果只是删除遍历时候碰到的第一个符合条件的元素，那么在earse之后添加break，使得不再进行遍历。如果要继续操作，那么就得改成，正确：
for (vector<int>::iterator iter = nums.begin(); iter != nums.end();)
{
if (*iter == 22)
iter=nums.erase(iter);
else
++iter;
}
或者
vector<int>::iterator iter = nums.begin();
while (iter != nums.end())
{
if (*iter == 22)
iter=nums.erase(iter);
else
iter++;
}
size、sizeof、strlen（最好不用sizeof）
对string或vector对象执行sizeof运算只返回该类型固定部分的大小（vector-16,string-28），不会计算对象中的元素占了多少空间。
对数组执行sizeof得到整个数组所占空间大小。
string res = "abcdef";
char s[] = "abcdef";
int a[] = {1,2,3};
cout << "size:" << res.size() << endl;
cout << "sizeof" << sizeof(res) << endl;
cout << "sizeof" << sizeof(s) << endl;
cout << "strlen" << strlen(s) << endl;
map用法
#include "stdafx.h"
#include <iostream>
#include <map>
using namespace std;
int main()
{
string str = "a00daaabbbsfg";
map<char, int> mp;
for (int i = 0; i<str.size(); ++i)
{
mp[str[i]]++;
}
for (map<char, int>::iterator iter = mp.begin(); iter != mp.end(); ++iter)
{
cout << iter->first << iter->second << endl;
}
cout <<mp.size()<<endl<< mp['a']<<endl;
return 0;
}
map<int, string> mapstudent;
//map插入元素的三种方式
mapstudent.insert(pair<int, string>(001, "stu1"));
mapstudent.insert(map<int, string>::value_type(001, "stu2"));
mapstudent[003] = "stu3";
//当map中有这个关键字时，insert操作是不能在插入数据的，但数组方式可以覆盖以前该关键字对应的值
// 查找元素,当所查找的关键key出现时，它返回数据所在对象的位置，如果沒有，返回iter与end函数的值相同。
map<int, string>::iterator iter = mapstudent.find(001);// iter=(1,"stu2")
//auto iter = mapstudent.find(006); //iter=end
if (iter != mapstudent.end())
cout << "Find, the value is " << iter->second << endl;
else
cout << "Do not Find" << endl;
查找元素还可以用count函数
if(maps.count(key)>0)
cout<<"find it!";
// 刪除与清空元素
auto iter = mapstudent.find(001);
mapstudent.erase(iter);
int n = mapstudent.erase(001); //如果刪除了會返回1，否則返回0,n=1;
int n = mapstudent.erase(004); //n=0;
mapstudent.erase(mapstudent.begin(), mapstudent.end());//用迭代器范围刪除 : 把整个map清空,等同于mapstudent.clear();
unordered_set用法，set和map内部实现是基于RB-Tree，而unordered_set和unordered_map内部实现是基于哈希表(hashtable)，无序集合容器（unordered_set）是一个存储唯一(unique，即无重复）的关联容器（Associative container）.
#include <unordered_set>
unordered_set<char> lookup = { 'v','b','v','b','a' };//lookup={'v','b','a'};
lookup.insert('c');//lookup={'v','b','a','c'};
lookup.erase('b');//lookup={'v','a','c'};
lookup.empty();
lookup.sizee();
for (unordered_set<char>::iterator ite = lookup.begin(); ite != lookup.end(); ite++)
{
cout << *ite;
}
lookup.clear();
unordered_set<char>::iterator find_iter = lookup.find('b');
lookup.count('v');//'v'出现的次数1
C++数组或vector求最大值最小值
可以用max_element（）及min_element（）函数，二者返回的都是迭代器或指针。
#include<algorithm>
求数组的最大值或最小值以及最大值最小值对应的下标
1）vector容器
vector<int> v; //v={2,5,4,7,3}
int maxValue = *max_element(v.begin(),v.end()); //最大值 7
int minValue = *min_element(v.begin(),v.end()); //最小值 2
int maxPosition = max_element(v.begin(),v.end()) - v.begin(); //最大值下标 3
int minPosition = min_element(v.begin(),v.end()) - v.begin(); //最小值下标 0
int sizev = v.size(); //vector大小 5
2）普通数组
int a[]={1,2,3,4,5,6};
int maxValue = *max_element(a,a+6); //最大值 6
int minValue = *min_element(a,a+6); //最小值 1
int maxPosition = max_element(a,a+6) - a; //最大值下标 5
int minPosition = min_element(a,a+6) - a; //最小值下标 0
int sizea=sizeof(a) / sizeof(int); //求数组的大小 6
//注意：最值下标返回的是第一个最大（小）元素的位置。
find函数
1、string中find()返回值是字母在母串中的位置（下标记录），如果没找到，返回一个特别的标记npos（4294967295，返回值可以看成是一个int型的数）
#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str1="abcde";
string str2="cdeab";
string str3 = str1 + str1;
int pos = str3.find(str2);// cout<<pos=2
string::size_type pos1= str3.find("aaa");//find函数返回类型size_type cout<<pos1=4294967295=npos
if (pos1 != string::npos) //if (pos1 != str3.npos)
cout << pos1 << endl;
else
cout << "not find!" << endl;
return 0;
}
//int pos = str3.find("aaa");// cout<<pos=-1，int型的pos可以和 string::npos比较判断if (pos != string::npos)
//auto pos1= str3.find("aaa");
//string::size_type pos1= str3.find(str2);//cout<<pos1=2 string::size_type类型的pos1可以和 string::npos比较判断
返回子串出现在母串中的首次出现的位置，和最后一次出现的位置。
auto position = str3.find_first_of('b'); //cout<<position=1
auto position1 = str3.find_last_of('b');//cout<<position1=6
返回子串出现在母串中的首次未出现的位置，和最后一次未出现的位置。
string str3 = "ab12";
auto position1 = str3.find_last_not_of('1'); //position1 =3
auto position1 = str3.find_last_not_of('2'); //position1 =2
auto position1 = str3.find_first_not_of('a'); //position1 =1
auto position1 = str3.find_first_not_of('v'); //position1 =0
查找某一给定位置后的子串的位置
auto position=str3.find("b",5);//从字符串str3下标5开始(包括5),查找字符串b,返回b在s中的下标 cout<<position=6
查找所有子串在母串中出现的位置
string::size_type pos;
pos = 0;
int i = 1;
while ((pos = str3.find("ab", pos)) != string::npos)
{
cout << "pos:" << i << ":" << pos << endl;
pos++; i++;
}
if(i==1)
cout << "not find";
return 0;
反向查找子串在母串中出现的位置,即字串在母串中最后出现的位置
pos = str3.rfind("a"); //cout<<pos=5
判断s是否是t的子序列
bool isSubsequence(string s, string t) {
int pos_s = 0;
for (int i = 0; i < t.size() && pos_s < s.size(); i++)
{
if (s[pos_s] == t[i])
pos_s++;
}
if (pos_s == s.size())
return true;
else
return false;
}
判断子串：
int strStr(string haystack, string needle) {
if(needle.empty()) return 0;
int m=haystack.size(),n=needle.size();
if(m<n) return -1;
for(int i=0;i<=m-n;++i)
{
int j=0;
for(j=0;j<n;++j)
{
if(haystack[i+j] != needle[j]) break;
}
if(j==n) return i;
}
return -1;
//return haystack.find(needle);
}
//查找vector的find
vector<int> num = {200,3,455,4};
vector<int>::iterator result = find(num.begin(), num.end(), 33);
if (result == num.end())
cout << "not find" << endl;
else
cout << "the postion:"<<(result - num.begin()) << endl;
反转字符串函数 reverse
#include <algorithm>
string s = "hello";
reverse(s.begin(),s.end()); //s="olleh"
进制转换函数
**10进制转任意进制:**
自己实现代码（10进制转任意进制，结果为string）：
string intToA(int n, int radix) //n是待转数字，radix是指定的进制
{
string ans = "";
do {
int t = n%radix;
if (t >= 0 && t <= 9) ans += t + '0';
else ans += t - 10 + 'a';
n /= radix;
} while (n != 0); //使用do{}while（）以防止输入为0的情况
reverse(ans.begin(), ans.end());
return ans;
}
#include <algorithm>
int num = 10;
string str = intToA(num, 2);//str=1010;
itoa函数：将一个10进制的数（value）转化为radix进制（2-36）的值、其返回值为char型。
函数原型：char*itoa(int value,char*string,int radix);
#include<cstdlib>
int main()
{
int num = 10;
char str[100]="";
_itoa_s(num, str, 2);//将十进制数num转换为2进制数存到str里面。str=1010
_itoa_s(num, str, 8);
return 0;
}
**任意进制转10进制**
自己实现代码
int Atoi(string s, int radix) //s是给定的radix进制字符串，返回10进制数
{
int ans = 0;
for (int i = 0; i<s.size(); i++)
{
char t = s[i];
if (t >= '0'&&t <= '9') ans = ans*radix + t - '0';
else ans = ans*radix + t - 'a' + 10;
}
return ans;
}
string str = "1010";
int num = Atoi(str, 2);//把2进制的1010转为10进制，num=10
strtol()函数, base是要转化的数的进制，非法字符会赋值给endptr，nptr是要转化的字符
函数原型：long int strtol(const char *nptr, char **endptr, int base)
char buffer[20] = "10549stend#12";
char *stop;
int ans = strtol(buffer, &stop, 8);//将八进制数1054转成十进制ans，后面9stend#12均为非法字符 ans=556,stop=9stend#12
char buffer[20] = "1010101";
char *stop;
int ans= strtol(buffer, &stop, 2);//将2进制数1010101转为10进制数ans，ans=85,stop=""
c++ stl栈stack，先进后出
头文件为:
#include <stack>
empty() 堆栈为空则返回真
pop() 移除栈顶元素
push() 在栈顶增加元素
size() 返回栈中元素数目
top() 返回栈顶元素
新建一个ListNode，在节点pnode后面新加一个节点
ListNode* t=new ListNode(1);//初始化节点的值为1
pnode->next=t;
pnode=pnode->next;
int n=-2147483648;
long absn=-1*(long)n;
或
long absn=n;absn=-absn;
编程实现从string中提取所有的数字
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <stdio.h>
#include <string>
using namespace std;
int main()
{
string str;
cin >> str;
int num_temp = 0;
bool isdig = false;
vector<int> num;
int sign = 1;
for (int i = 0; i < str.size(); ++i)
{
if (str[i] == '-' && isdigit(str[i + 1]))
{
sign = -1;
continue;
}
if (isdigit(str[i]))
{
num_temp = num_temp * 10 + (str[i]-'0');
isdig = true;
}
else
{
if (isdig)
{
num.push_back(num_temp*sign);
isdig = false;
num_temp = 0;
sign = 1;
}
}
}
if(num_temp!=0)
num.push_back(num_temp);
return 0;
}
int myAtoi(string str) {
int i=0;//位置
long res=0;
int sign=1;//符号
while(i<str.size() && str[i]==' ') ++i;//找到第一个非空格的字符位置
if(i == str.size()) return 0;
if(str[i]=='-') {sign=-1;i++;}
else if(str[i]=='+') i++;
while(i<str.size() && isdigit(str[i]))
{
res=res*10+(str[i++]-'0');
if(res>INT_MAX){
if(sign==1) return INT_MAX;
else return INT_MIN;
}
}
return res*sign;
}
自定义函数传参数时，如果传入的参数在函数中未被改动，直接值传入或者地址传入都可以，如果传入的参数会被改动，必须用地址引用传入参数。（&）
void combinationSum(vector& candidates, int target,int i)；
回溯法
class Solution {
public:
vector<vector<int> > res;
vector<int > curr;
vector<vector<int>> permute(vector<int>& nums) {
if(nums.empty()) return res;
vector<bool> flag(nums.size(),false);//标记元素是否被访问过
permu(nums,flag,0);
return res;
}
void permu(vector<int>& nums,vector<bool>& flag,int index)
{
if(index==nums.size())
{
res.push_back(curr);
return;
}
for(int i=0;i<nums.size();++i)
{
// if(!flag[i])
// {
// flag[i]=true;
curr.push_back(nums[i]);
permu(nums,flag,index+1);
curr.pop_back();
// flag[i]=false;
// }
}
}
};
把注释去掉：
c++全排列函数：next_permutation
#include <algorithm>
bool next_permutation(iterator start,iterator end)
当前序列不存在下一个排列时，函数返回false，否则返回true。数据必须有序且为整数。
vector<int> nums = {1,2,3};
vector<vector<int>> result;
sort(nums.begin(), nums.end());
result.push_back(nums);
while (next_permutation(nums.begin(), nums.end()))
{
result.push_back(nums);
}
处理输入：
1、输入只有一行
int n=0,m=0,k=0;
cin>>n>>m>>k;
2、输入是2行，第一行表示第二行有多少个数，把所有的数存起来。
int n;
cin>>n;
vector<int> dianshu(n,0);
for(int i=0;i<n;++i)
{
int temp;
cin>>temp;
dianshu[i] = temp;
}
int n;
cin>>n;
vector<int> input;
for(int i=0;i<n;++i)
{
int temp;
cin>>temp;
input.push_back(temp);
}
3、输入是一行字符串，中间用‘,‘分开，把输入字符串中的数字提取到vector中。
string str;
cin >> str;
vector<int> data;
int i = 0;
int N = 0;
while (i<str.size())
{
int left = i;
while (i<str.size() && str[i] != ',' && str[i] != ';')
++i;
int right = i - 1;
string tempstr = str.substr(left, right - left + 1);
int num = stoi(tempstr);
data.push_back(num);
if (str[i] == ',')
++i;
else if (str[i] == ';')
{
++i;
string temp = str.substr(i);
N = stoi(temp);
break;
}
}
二分查找
1、查找和目标值完全相等的数
数组 [2, 4, 5, 6, 9]，target = 6，return 3
int find1(vector<int>& nums,int target)
{
int left = 0, right = nums.size();
while (left < right)
{
int mid = left + (right - left) / 2;
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else
right = mid;
}
return -1;
}
int find2(vector<int>& nums, int target)
{
int left = 0, right = nums.size()-1;
while (left <= right)
{
int mid = left + (right - left) / 2;
if (nums[mid] == target)
return mid;
else if (nums[mid] < target)
left = mid + 1;
else
right = mid-1;
}
return -1;
}
2、查找第一个不小于目标值的数，lower_bound函数也可
可变形为查找最后一个小于目标值的数
在数组 [2, 4, 5, 6, 9] 中查找数字3，就会返回数字4的位置；
在数组 [0, 1, 1, 1, 1] 中查找数字1，就会返回第一个数字1的位置。
int find(vector<int>& nums, int target) {
int left = 0, right = nums.size();
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] < target) left = mid + 1;
else right = mid;
}
//returned right-1；返回 right - 1，就是最后一个小于目标值的数。
return right;
}
3、查找第一个大于目标值的数，upper_bound
可变形为查找最后一个不大于目标值的数
在数组 [2, 4, 5, 6, 9] 中查找数字3，还是返回数字4的位置，
在数组 [0, 1, 1, 1, 1] 中查找数字1，就会返回坐标5
int find(vector<int>& nums, int target) {
int left = 0, right = nums.size();
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] <= target) left = mid + 1;
else right = mid;
}
//return right-1;//返回 right - 1，就是最后一个不大于目标值的数。
return right;
}
快速排序：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。
三数取中、如果数组非常小，适合用直接插入排序。
#include "stdafx.h"
#include <iostream>
#include <vector>
using namespace std;
int PartSort(vector<int>& arr, int low, int high)
{
int mid = low + (high - low) / 2;
if (arr[low] > arr[high])
swap(arr[low],arr[high]);
if (arr[mid] > arr[high])
swap(arr[mid], arr[high]);
if (arr[mid] > arr[low])
swap(arr[mid], arr[low]);
int pivotkey = arr[low];
while (low < high)
{
while (low < high && arr[high] >= pivotkey)
high--;
arr[low] = arr[high];
while (low < high && arr[low] <= pivotkey)
low++;
arr[high] = arr[low];
}
arr[low] = pivotkey;
return low;
}
//int arr[]
void Qsort(vector<int>& arr, int low, int high)
{
int pivot = 0;
while (low < high)
{
pivot = PartSort(arr,low,high);
Qsort(arr, low, pivot - 1);
low = pivot + 1;
}
}
int main()
{
vector<int> arr{5,1,9,3,7,4,8,6,2};
Qsort(arr, 0, arr.size() - 1);
for (auto i : arr)
cout << i << endl;
return 0;
}
无序数组找第K大的数
int PartSort(vector<int>& arr, int low, int high)
{
int pivotkey = arr[low];
while (low < high)
{
while (low < high && arr[high] >= pivotkey)
high--;
arr[low] = arr[high];
while (low < high && arr[low] <= pivotkey)
low++;
arr[high] = arr[low];
}
arr[low] = pivotkey;
return low;
}
void findKMax(vector<int>& arr, int low, int high, int k)
{
int temp = PartSort(arr, low, high);
if (temp == k - 1)
cout << arr[temp]<<endl;
else if (temp > k - 1)
findKMax(arr, low, temp - 1, k);
else
findKMax(arr, temp + 1, high, k);
}
int main()
{
vector<int> arr{ 5,1,9,3,7,4,8,6,2 };
findKMax(arr, 0, arr.size() - 1, 4);
return 0;
}
层次遍历构造二叉树
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
void insert(TreeNode *p, vector<int> temp, int t) {
int length = temp.size();
if (t >= length)return;
p->val = temp[t];
if ((2 * (t + 1)) <= length) {
if (temp[2 * (t + 1) - 1] != 0) {
TreeNode *l;
l = (TreeNode*)malloc(sizeof(TreeNode));
l->left = NULL;
l->right = NULL;
p->left = l;
insert(p->left, temp, 2 * (t + 1) - 1);
}
if ((2 * (t + 1) + 1) <= length) {
if (temp[2 * (t + 1)] != 0) {
TreeNode *r;
r = (TreeNode*)malloc(sizeof(TreeNode));
r->left = NULL;
r->right = NULL;
p->right = r;
insert(p->right, temp, 2 * (t + 1));
}
}
}
}
TreeNode* createFromArray(vector<int> temp) {
TreeNode *p;
p = (TreeNode*)malloc(sizeof(TreeNode));
p->left = NULL;
p->right = NULL;
insert(p, temp, 0);
return p;
}
void inorder(TreeNode* root)
{
if (root == nullptr)
return;
inorder(root->left);
cout<<root->val<<endl;
inorder(root->right);
}
int main()
{
int n = 0;
cin >> n;
n=pow(2,n)-1;
vector<int> vec(n, 0);
for (int i = 0; i<n; ++i)
{
int t = 0;
cin >> t;
vec[i] = t;
}
TreeNode* node=createFromArray(vec);//层次遍历构造二叉树
inorder(node);
return 0;
}
大数运算
string sum(string ans, string b) {
if (ans.length()<b.length()) ans.swap(b);
for (int i = ans.length() - 1, j = b.length() - 1; i >= 0; i--, j--) {
ans[i] = ans[i] + (j >= 0 ? b[j] - '0' : 0);
if (ans[i]>'9') {
ans[i] -= 10;
if (i>0) ans[i - 1]++;
else ans.insert(0, "1");
}
}
return ans;
}
string subtract(string ans, string b) {
int flag = 0;
if (ans.length()<b.length() || ans.length() == b.length() && ans<b) {
flag = 1;
ans.swap(b);
}
for (int i = ans.length() - 1, j = b.length() - 1; i >= 0; i--, j--) {
ans[i] = ans[i] - (j >= 0 ? b[j] - '0' : 0);
if (ans[i]<'0') {
ans[i] += 10;
--ans[i - 1];
}
}
while (ans.length() && ans[0] == '0') ans.erase(ans.begin());
if (flag) ans.insert(0, "-");
if (ans.empty()) return "0";
return ans;
}
string multiply(string a, string b) {
int m = a.length(), n = b.length();
vector<int>tmp(m + n - 1);
for (int i = 0; i<m; i++)
for (int j = 0; j<n; j++)
tmp[i + j] += (a[i] - '0')*(b[j] - '0');
for (int i = tmp.size() - 1; i>0; i--) {
tmp[i - 1] += tmp[i] / 10;
tmp[i] %= 10;
}
while (tmp[0]>9) {
tmp.insert(tmp.begin(), tmp[0] / 10);
tmp[1] %= 10;
}
string ans;
for (int i = 0, len = tmp.size(); i<len; i++)
ans += tmp[i] + '0';
if (ans[0] == '0') return "0";
return ans;
}
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <stack>
using namespace std;
struct Cmp
{
bool operator()(const char& a, const char& b) const
{
if (islower(a))
{
if (islower(b))
{
return a < b;
}
else
{
if (tolower(b) == a)
{
return true;
}
else
{
return a < tolower(b);
}
}
}
else
{
if (isupper(b))
{
return a < b;
}
else
{
if (toupper(b) == a)
{
return false;
}
else
{
return a < toupper(b);
}
}
}
}
};
int main()
{
string s = "AAbACdDe";
map<char, vector<int>, Cmp> m;
for (int i = 0; i < s.size(); ++i)
{
m[s[i]].push_back(i);// m: A,0,1,3
}
return 0;
}
输出六位小数
printf("%.6f", res);
vector里面存pair
vector<pair<int, int>> a;
for (int i = 1; i <= 5; ++i)
a.push_back(make_pair(i, i+1));
cout << a[1].first<<" "<<a[2].second << endl; //2 4
扫一扫
226
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
