标签（空格分隔）： C++ leetcode
一些成型的代码段
A: 去除 vector
vector new_num(vector& nums) {
sort(nums.begin(),nums.end());
nums.erase(unique(nums.begin(),nums.end()),nums.end());
return nums;
}
A_: 将一串数组的任何两个值的和以及他们的对应的下标给记录下来
//这里的时间复杂度是O(n^2)
unordered_map>> mapping;
for(int i =0;i(a,b));
}
// 通过这种方式，可以将一串数组的任何两个值的和以及他们的对应的下标给记录下来
B: 从字符串里面读取所需要的int 和 char 型的数据
void build_tree(string s1,string s2) {
string vec="";
map tree;
istringstream v1(s1);
int i;
char c;
while(v1.good()){
v1>>c>>i;
tree[i]=tree[i]+c;
//
}
}
对于 map 和 unordered_map 的初始化操作
void load_op(map& record, string name){
if(record.find(name)==record.end()) record[name]=1;
else ++record[name];
}
对于 map 如何根据value值进行排序（爱死了 sort 这个函数，直接重载这个函数运算符）
map默认按照key值排序，而map又没有像vector一样的sort()函数，那么如果将map按照value值排序呢？有两种方法：
方法1. 将map中的key和value分别存放在一个pair类型的vector中，然后利用vector的sort函数排序，其中map_verb存放我的map值：
存放我的map值：
#include
typedef pair PAIR; // typedef 这里是有类型检查的
int cmp(const PAIR &x, const PAIR &y){
return x.second > y.second;
}
for (map::iterator map_iter = map_verb.begin(); map_iter != map_verb.end(); ++map_iter){
pair_vec.push_back(make_pair(map_iter->first, map_iter->second));
}
sort(pair_vec.begin(), pair_vec.end(), cmp);
for (vector::iterator curr = pair_vec.begin(); curr != pair_vec.end(); ++curr){
outfile << curr->first << "\t" << curr->second << endl;
}
提炼，pair对的生成：
int main(void){
vector> vec;
// pair p1 = pair(1,1);
// pair p2 = pair(2,2);
vec.push_back(pair(1,'a')); // vec.push_back(make_pair(1,'a'));
vec.push_back(pair(2,'b')); // vec.push_back(make_pair(2,'b'));
vector>::iterator itr;
for(itr=vec.begin();itr!=vec.end();itr++){
cout<first<second< 方法2. 再新建一个map结构，然后把已知的map值得key和value分别作为新map的value和key，这样map结构就会自动按照value值排序啦.
对于 string 类型的数据，怎么进行查找 find(vec.begin(),vec.end(),c)==vec.end()
string 的查找的数据的位置：
int main(void){
string str="abcdef";
auto i = str.begin();
auto j = find(str.begin(),str.end(),'d');
cout<char 是一个数字，怎么转为 int, 以及怎么将 一个 int 转为 一个 char：
int main(void){
// char c = '3' ;
// int n = c -'0';
// cout<< n;
int n = 3;
char c = n + '0';
cout<另外用以下static_cast
int main(void){
int n = 48;
char c = static_cast(n); //这里 ASCII码里面，48代表着就是0，所以，强行转换后，就变成了0；
cout< 案例：
void find_depth(map tree,string vec, char c){
if(find(vec.begin(),vec.end(),c)==vec.end()) return ;
int i=distance(vec.begin(),find(vec.begin(),vec.end(),c)); //这个i就是那个元素的下标.
}
//这里的时间复杂度是O(n^2)
unordered_map>> mapping;
for(int i =0;i(a,b));
}
通过这种方式，可以将一串数组的任何两个值的和以及他们的对应的下标给记录下来
算法应用：寻找出现次数最多的子串
对于 string 而言，如果要遍历它的子串，找到出现最多的子串是哪一个的时候，最简单的方法就是打算遍历所有的子串，利用map实现，其键值为对应的子串，value为子串出现的个数，遍历完所有的子串后，只要寻找最大的value的键值就可以了，这里就想到一个问题，map一般是按键排序，能否按value进行排序呢？
void substrCount(string str)
{
map substr;
string subs;
for(int i =1; i maxpair = *(substr.begin()); //寻找出现次数最多的子串
map::iterator it = substr.begin();
while(it!=substr.end())
{
if(it->second >maxpair.second )
maxpair = *it;
}
cout< 对 pair 对使用的一个比较好的技巧：对于一个map而言，每一个键值对都可以转换为pair，所以，就出现了：pair
按键排序
为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。在我们插入
map 的模板定义如下：
template
其中第三、四个均包含默认参数，可以不指定。我们可以通过指定Compare类来指定排序的顺序。其中less
多线程单例模式
#include "afxmt.h"
class Lock
{
private:
CCriticalSection m_cs; // 类CCriticalSection 的对象表示一个临界区，它是一个用于同步的对象，同一时刻只允许一个线程存取资源或代码区。
public:
Lock(CCriticalSection cs) : m_cs(cs)
{
m_cs.Lock();
}
~Lock()
{
m_cs.Unlock();
}
};
class Singleton
{
private:
Singleton();
Singleton(const Singleton &);
Singleton& operator = (const Singleton &);
public:
static Singleton *Instantialize();
static Singleton *pInstance;
static CCriticalSection cs;
};
Singleton* Singleton::pInstance = 0;
Singleton* Singleton::Instantialize()
{
if(pInstance == NULL)
{
//double check
Lock lock(cs); //用lock实现线程安全，用资源管理类，实现异常安全
//使用资源管理类，在抛出异常的时候，资源管理类对象会被析构，析构总是发生的无论是因为异常抛出还是语句块结束。
if(pInstance == NULL)
{
pInstance = new Singleton();
}
}
return pInstance;
}
vector 和 string 优先于动态分配的数组
首先，在性能上，由于vector能够保证连续内存，因此一旦分配了后，它的性能跟原始数组相当；
其次，如果用new， 意味着你要确保后面进行了delete, 一旦忘记了，就会出现BUG，且这样需要都写一行delete,代码不够短。
再次，声明多维数组的话，只能一个一个new，例如：
int** ary = new int*[row_num];
for(int i = 0;i < row_num; ++i)
ary[i] = new int[col_num];
用 vector 的话一行代码搞定:
vector > ary(row_num, vector(col_num, 0));
使用 reserve 来避免不必要的重新分配
在无序地情况下进行二分查找（用快排进行实现，但是快排有个最大的问题，就是如果是在有序地情况下会退化成冒泡排序，所以这个地方的种子数据，就需要选的相对随机一点）
输入
第1行：2个整数N,K。N表示数组长度，K表示需要查找的数；
第2行：N个整数，表示a[1..N]，保证不会出现重复的数，1≤a[i]≤2,000,000,000。 （注意，这里2000000000< 2147483647 所以用Int 型就可以了，4个字节可以表示的数也是很大的。）
输出
第1行：一个整数t，表示K在数组中是第t小的数，若K不在数组中，输出-1。
样例输入
10 5180
2970 663 5480 4192 4949 1 1387 4428 5180 2761
样例输出
9
#include
#include
#include
#include
using namespace std;
int my_find(vector &nums,int target,int left_,int right_){
int left=left_,right=right_;
if(left==right&&nums[left]!=target) return -1;
swap(nums[left],nums[(left+right)/2]);
int cur = nums[left];
while(left=cur) right--;
if(leftcur) return my_find(nums,target,left+1,right_);
}
int main(){
int row=0,target=0;
vector nums;
scanf("%d",&row);
scanf("%d",&target);
int num=0;
while(row>0){
scanf("%d",&num);
nums.push_back(num);
row--;
}
cout< 二分查找之第第K小的数，以及二分查找之第k大的数的标准做法
#include
#include
#include
#include
using namespace std;
int my_find(vector &nums,int target,int left_,int right_){
int left=left_,right=right_;
if(left==right&&left!=target) return -1;
swap(nums[left],nums[(left+right)/2]);
int cur = nums[left];
while(left=cur) right--;
if(leftleft) return my_find(nums,target,left+1,right_);
}
int main(){
int row=0,target=0;
vector nums;
scanf("%d%d",&row,&target);
int num=0;
while(row>0){
scanf("%d",&num);
nums.push_back(num);
row--;
}
cout< 一些成型的代码段
A: 去除 vector
vector new_num(vector& nums) {
sort(nums.begin(),nums.end());
nums.erase(unique(nums.begin(),nums.end()),nums.end());
return nums;
}
B: 从字符串里面读取所需要的int 和 char 型的数据
void build_tree(string s1,string s2) {
string vec="";
map tree;
istringstream v1(s1);
int i;
char c;
while(v1.good()){
v1>>c>>i;
tree[i]=tree[i]+c;
//
}
}
对于 map 和 unordered_map 的初始化操作
void load_op(map& record, string name){
if(record.find(name)==record.end()) record[name]=1;
else ++record[name];
}
对于 map 如何根据value值进行排序（爱死了 sort 这个函数，直接重载这个函数运算符）
map默认按照key值排序，而map又没有像vector一样的sort()函数，那么如果将map按照value值排序呢？有两种方法：
方法1. 将map中的key和value分别存放在一个pair类型的vector中，然后利用vector的sort函数排序，其中map_verb存放我的map值：
存放我的map值：
#include
typedef pair PAIR; // typedef 这里是有类型检查的
int cmp(const PAIR &x, const PAIR &y){
return x.second > y.second;
}
for (map::iterator map_iter = map_verb.begin(); map_iter != map_verb.end(); ++map_iter){
pair_vec.push_back(make_pair(map_iter->first, map_iter->second));
}
sort(pair_vec.begin(), pair_vec.end(), cmp);
for (vector::iterator curr = pair_vec.begin(); curr != pair_vec.end(); ++curr){
outfile << curr->first << "\t" << curr->second << endl;
}
提炼，pair对的生成：
int main(void){
vector> vec;
// pair p1 = pair(1,1);
// pair p2 = pair(2,2);
vec.push_back(pair(1,'a')); // vec.push_back(make_pair(1,'a'));
vec.push_back(pair(2,'b')); // vec.push_back(make_pair(2,'b'));
vector>::iterator itr;
for(itr=vec.begin();itr!=vec.end();itr++){
cout<first<second< 方法2. 再新建一个map结构，然后把已知的map值得key和value分别作为新map的value和key，这样map结构就会自动按照value值排序啦.
对于 string 类型的数据，怎么进行查找 find(vec.begin(),vec.end(),c)==vec.end()
string 的查找的数据的位置：
int main(void){
string str="abcdef";
auto i = str.begin();
auto j = find(str.begin(),str.end(),'d');
cout<char 是一个数字，怎么转为 int, 以及怎么将 一个 int 转为 一个 char：
int main(void){
// char c = '3' ;
// int n = c -'0';
// cout<< n;
int n = 3;
char c = n + '0';
cout<另外用以下static_cast
int main(void){
int n = 48;
char c = static_cast(n); //这里 ASCII码里面，48代表着就是0，所以，强行转换后，就变成了0；
cout< 案例：
void find_depth(map tree,string vec, char c){
if(find(vec.begin(),vec.end(),c)==vec.end()) return ;
int i=distance(vec.begin(),find(vec.begin(),vec.end(),c)); //这个i就是那个元素的下标.
}
算法应用：寻找出现次数最多的子串
对于 string 而言，如果要遍历它的子串，找到出现最多的子串是哪一个的时候，最简单的方法就是打算遍历所有的子串，利用map实现，其键值为对应的子串，value为子串出现的个数，遍历完所有的子串后，只要寻找最大的value的键值就可以了，这里就想到一个问题，map一般是按键排序，能否按value进行排序呢？
void substrCount(string str)
{
map substr;
string subs;
for(int i =1; i maxpair = *(substr.begin()); //寻找出现次数最多的子串
map::iterator it = substr.begin();
while(it!=substr.end())
{
if(it->second >maxpair.second )
maxpair = *it;
}
cout< 对 pair 对使用的一个比较好的技巧：对于一个map而言，每一个键值对都可以转换为pair，所以，就出现了：pair
按键排序
为了实现快速查找，map内部本身就是按序存储的（比如红黑树）。在我们插入
map 的模板定义如下：
template
其中第三、四个均包含默认参数，可以不指定。我们可以通过指定Compare类来指定排序的顺序。其中less