duanyajun987
duanyajun987

algorithm库函数集合：

algorithm库函数集合：


1.不修改内容的序列操作：

adjacent_find 查找两个相邻（Adjacent）的等价（Identical）元素
all_ofC++11 检测在给定范围中是否所有元素都满足给定的条件
any_ofC++11 检测在给定范围中是否存在元素满足给定条件
count 返回值等价于给定值的元素的个数
count_if 返回值满足给定条件的元素的个数
equal 返回两个范围是否相等
find 返回第一个值等价于给定值的元素
find_end 查找范围A中与范围B等价的子范围最后出现的位置
find_first_of 查找范围A中第一个与范围B中任一元素等价的元素的位置
find_if 返回第一个值满足给定条件的元素
find_if_notC++11 返回第一个值不满足给定条件的元素
for_each 对范围中的每个元素调用指定函数
mismatch 返回两个范围中第一个元素不等价的位置
none_ofC++11 检测在给定范围中是否不存在元素满足给定的条件
search 在范围A中查找第一个与范围B等价的子范围的位置
search_n 在给定范围中查找第一个连续n个元素都等价于给定值的子范围的位置

2.修改内容的序列操作：

copy 将一个范围中的元素拷贝到新的位置处
copy_backward 将一个范围中的元素按逆序拷贝到新的位置处
copy_ifC++11 将一个范围中满足给定条件的元素拷贝到新的位置处
copy_nC++11 拷贝 n 个元素到新的位置处
fill 将一个范围的元素赋值为给定值
fill_n 将某个位置开始的 n 个元素赋值为给定值
generate 将一个函数的执行结果保存到指定范围的元素中，用于批量赋值范围中的元素
generate_n 将一个函数的执行结果保存到指定位置开始的 n 个元素中
iter_swap 交换两个迭代器（Iterator）指向的元素
moveC++11 将一个范围中的元素移动到新的位置处
move_backwardC++11 将一个范围中的元素按逆序移动到新的位置处
random_shuffle 随机打乱指定范围中的元素的位置
remove 将一个范围中值等价于给定值的元素删除
remove_if 将一个范围中值满足给定条件的元素删除
remove_copy 拷贝一个范围的元素，将其中值等价于给定值的元素删除
remove_copy_if 拷贝一个范围的元素，将其中值满足给定条件的元素删除
replace 将一个范围中值等价于给定值的元素赋值为新的值
replace_copy 拷贝一个范围的元素，将其中值等价于给定值的元素赋值为新的值
replace_copy_if 拷贝一个范围的元素，将其中值满足给定条件的元素赋值为新的值
replace_if 将一个范围中值满足给定条件的元素赋值为新的值
reverse 反转排序指定范围中的元素
reverse_copy 拷贝指定范围的反转排序结果
rotate 循环移动指定范围中的元素
rotate_copy 拷贝指定范围的循环移动结果
shuffleC++11 用指定的随机数引擎随机打乱指定范围中的元素的位置
swap 交换两个对象的值
swap_ranges 交换两个范围的元素
transform 对指定范围中的每个元素调用某个函数以改变元素的值
unique 删除指定范围中的所有连续重复元素，仅仅留下每组等值元素中的第一个元素。
unique_copy 拷贝指定范围的唯一化（参考上述的 unique）结果

3.划分操作：

is_partitionedC++11 检测某个范围是否按指定谓词（Predicate）划分过
partition 将某个范围划分为两组
partition_copyC++11 拷贝指定范围的划分结果
partition_pointC++11 返回被划分范围的划分点
stable_partition 稳定划分，两组元素各维持相对顺序

4.排序操作：

is_sortedC++11 检测指定范围是否已排序
is_sorted_untilC++11 返回最大已排序子范围
nth_element 部份排序指定范围中的元素，使得范围按给定位置处的元素划分
partial_sort 部份排序
partial_sort_copy 拷贝部分排序的结果
sort 排序
stable_sort 稳定排序

5.二分法查找操作：

binary_search 判断范围中是否存在值等价于给定值的元素
equal_range 返回范围中值等于给定值的元素组成的子范围
lower_bound 返回指向范围中第一个值大于或等于给定值的元素的迭代器
upper_bound 返回指向范围中第一个值大于给定值的元素的迭代器

6.集合操作：

includes 判断一个集合是否是另一个集合的子集
inplace_merge 就绪合并
merge 合并
set_difference 获得两个集合的差集
set_intersection 获得两个集合的交集
set_symmetric_difference 获得两个集合的对称差
set_union 获得两个集合的并集

7.堆操作：

is_heap 检测给定范围是否满足堆结构
is_heap_untilC++11 检测给定范围中满足堆结构的最大子范围
make_heap 用给定范围构造出一个堆
pop_heap 从一个堆中删除最大的元素
push_heap 向堆中增加一个元素
sort_heap 将满足堆结构的范围排序

8.最大/最小操作：

is_permutationC++11 判断一个序列是否是另一个序列的一种排序
lexicographical_compare 比较两个序列的字典序
max 返回两个元素中值最大的元素
max_element 返回给定范围中值最大的元素
min 返回两个元素中值最小的元素
min_element 返回给定范围中值最小的元素
minmaxC++11 返回两个元素中值最大及最小的元素
minmax_elementC++11 返回给定范围中值最大及最小的元素
next_permutation 返回给定范围中的元素组成的下一个按字典序的排列
prev_permutation 返回给定范围中的元素组成的上一个按字典序的排列

一，巡防算法

        for_each(容器起始地址，容器结束地址，要执行的方法)

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. template<class T>  
  8. struct plus2  
  9. {  
  10.     void operator()(T&x)const  
  11.     {  
  12.         x+=2;  
  13.     }  
  14.       
  15. };  
  16.   
  17. void printElem(int& elem)  
  18. {  
  19.   cout << elem << endl;  
  20. }  
  21.   
  22.   
  23. int main()  
  24. {  
  25.     int ia[]={0,1,2,3,4,5,6};  
  26.     for_each(ia,ia+7,printElem);//输出  
  27.       
  28.     int ib[]={7,8,9,10,11,12,13};  
  29.     vector<int> iv(ib,ib+7);  
  30.     for_each(iv.begin(),iv.end(),plus2<int>());//更改元素  
  31.     for_each(iv.begin(),iv.end(),printElem);//输出  
  32.       
  33.       
  34.     return 0;  
  35. }  

二，find算法

   int *find(int *begin，int *end，int  value)

   前闭后合的区间 begin，end中，查找value如果查找到了就返回第一个符合条件的元素，否则返回end指针

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3.   
  4. using namespace std;  
  5.   
  6. void printElem(int& elem)  
  7. {  
  8.   cout << elem << endl;  
  9. }  
  10.   
  11.   
  12. int main()  
  13. {  
  14.     int ia[]={0,1,2,3,4,5,6};  
  15.       
  16.     int *i= find(ia,ia+7,9);//在整个数组中查找元素 9   
  17.     int *j= find(ia,ia+7,3);//在整个数组中查找元素 3  
  18.     int *end=ia+7;//数组最后位置   
  19.     if(i == end)   
  20.        cout<<"没有找到元素 9"<
  21.     else   
  22.        cout<<"找到元素9"<
  23.          
  24.     if(j == end)   
  25.        cout<<"没有找到元素 3"<
  26.     else   
  27.        cout<<"找到元素"<<*j<
  28.     return 0;  
  29. }  

三，数值算法

        包含在头文件中

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   //数值算法   
  3. #include   
  4. #include    
  5. #include    
  6.   
  7. #include    
  8.  using namespace std;  
  9.    
  10.  int main()  
  11.  {  
  12.     int ia[]={1,2,3,4,5};  
  13.     vector<int> iv(ia,ia+5);  
  14.       
  15.     cout<//累加  初值为0   
  16.     cout<int>())<//累加 符号位负  
  17.        
  18.     cout<//两个数组内积  初值为10   
  19.     cout<int>(),plus<int>())<//10-(1+1)-(2+2)  
  20.       
  21.     ostream_iterator<int> oite(cout," ");//迭代器绑定到cout上作为输出使用  
  22.     partial_sum(iv.begin(),iv.end(),oite);//依次输出前n个数的和   
  23.       
  24.     cout<
  25.     partial_sum(iv.begin(),iv.end(),oite,minus<int>());//依次输出第一个数减去（除第一个数外到当前数的和）  
  26.       
  27.     cout<
  28.     adjacent_difference(iv.begin(),iv.end(),oite); //输出相邻元素差值 前面-后面  
  29.       
  30.     cout<
  31.     adjacent_difference(iv.begin(),iv.end(),oite,plus<int>()); //输出相邻元素差值 前面+后面  。前面更改影响后面元素   
  32.        
  33.        
  34.     cout<
  35.     cout<// 平方  
  36.       
  37.     /*  VC 不支持   只有安装了才SGI STL支持  
  38.     int n=3; 
  39.     iota(iv.begin(),iv.end(),n);//在指定区间填入n  n+1 n+2 
  40.     for(int i=0;i 
  41.         cout< 
  42.          
  43.         */   
  44.     return 0;  
  45.  }  

四，基本算法

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6.   
  7. template<typename T>  
  8. struct display  
  9. {  
  10.     void operator()(const T  &x)const  
  11.     {  
  12.         cout<" ";  
  13.     }  
  14.       
  15. };  
  16.   
  17.   
  18. int main()  
  19. {  
  20.     int ia[]={0,1,2,3,4,5,6,7,8};  
  21.     vector<int> iv1(ia,ia+5);  
  22.     vector<int> iv2(ia,ia+9);  
  23.       
  24.     pairint>::iterator,vector<int>::iterator> pa;  
  25.     pa=mismatch(iv1.begin(),iv1.end(),iv2.begin());  
  26.     cout<<"两个数组不同点--第一个数组点:"<<*(pa.first)<//这样写很危险，应该判断是否到达end   
  27.     cout<<"两个数组不同点--第二个数组点:"<<*(pa.second)<
  28.       
  29.     //更改之后  
  30.     if(pa.first == iv1.end())  
  31.         cout<<"第一个数组与第二个数组匹配"<
  32.           
  33.     cout<// 1 表示 相等，因为只比较跟 iv1长度大小的数组   
  34.     cout<// 0 表示 不相等   
  35.     cout<int>())<// 1 表示 前者小于后者  
  36.       
  37.     fill(iv1.begin(),iv1.end(),9);//将iv1区间内填满 9  
  38.     for_each(iv1.begin(),iv1.end(),display<int>());  
  39.     cout<
  40.       
  41.     fill_n(iv1.begin(),3,6);//从iv1区间开始填 3个6   
  42.     for_each(iv1.begin(),iv1.end(),display<int>());  
  43.     cout<
  44.       
  45.       
  46.     vector<int>::iterator ite1=iv1.begin();  
  47.     vector<int>::iterator ite2=ite1;  
  48.     advance(ite2,3);//向前跳3个  
  49.       
  50.     iter_swap(ite1,ite2);//交换迭代器指向的元素  
  51.     for_each(iv1.begin(),iv1.end(),display<int>());  
  52.        
  53.     cout<<"\nmax:"<
  54.     cout<<"min:"<
  55.       
  56.     swap(*ite1,*ite2);  
  57.     for_each(iv1.begin(),iv1.end(),display<int>());  
  58.       
  59.       
  60.     cout<
  61.     string stra1[]={"a","b","c"};  
  62.     string stra2[]={"d","e","f"};  
  63.       
  64.     cout<//按照字典序 前者小于后者   
  65.     cout<())<//按照字典序 前者不大于后者  
  66.       
  67.           
  68.     return 0;  
  69. }  
五，copy（）对不同容器复制；关于输出区间与输入区间重叠的讨论

五，copy（）对不同容器复制；关于输出区间与输入区间重叠的讨论

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4.   
  5. using namespace std;  
  6. template<class T>  
  7. struct display  
  8. {  
  9.     void operator()(const T &x)const  
  10.     {  
  11.         cout<" ";  
  12.     }  
  13. };  
  14.   
  15. int main()  
  16. {  
  17.     //以下复制区间没有问题   
  18.     int ia1[]={0,1,2,3,4,5,6,7,8};  
  19.     copy(ia1+2,ia1+7,ia1);//将下标2-6复制给 1-5  
  20.     for_each(ia1,ia1+9,display<int>()); //2,3,4,5,6,5,6,7,8  
  21.     cout<
  22.        
  23.     //输出区间的起点与输入区间重叠，可能会有问题。但本例copy采用memmove()执行实际复制操作   
  24.     int ia2[]={0,1,2,3,4,5,6,7,8};  
  25.     copy(ia2+2,ia2+7,ia2+4);//将下标2-6复制给 4-8  
  26.     for_each(ia2,ia2+9,display<int>()); //0,1,2,3,2,3,4,5,6  
  27.     cout<
  28.       
  29.     //以下复制区间没有问题   
  30.     int ia3[]={0,1,2,3,4,5,6,7,8};  
  31.     deque<int> id(ia3,ia3+9);  
  32.     deque<int>::iterator first=id.begin();  
  33.     deque<int>::iterator last=id.end();  
  34.     deque<int>::iterator result=id.begin();  
  35.     ++++first;  
  36.     cout<<*first<
  37.     ----last;  
  38.     cout<<*last<
  39.     cout<<*result<
  40.     copy(first,last,result);  
  41.     for_each(id.begin(),id.end(),display<int>());//2,3,4,5,6,5,6,7,8  
  42.     cout<
  43.       
  44.     //以下复制区间存在问题，由于实际复制没有采用memove()，结果错误   
  45.     int ia4[]={0,1,2,3,4,5,6,7,8};  
  46.     deque<int> ide(ia4,ia4+9);  
  47.     deque<int>::iterator first1=ide.begin();  
  48.     deque<int>::iterator last1=ide.end();  
  49.     deque<int>::iterator result1=ide.begin();  
  50.     advance(result1,4);//注意这里跟上面不一样   
  51.     ++++first1;  
  52.     cout<<*first1<
  53.     ----last1;  
  54.     cout<<*last1<
  55.     cout<<*result1<
  56.     copy(first1,last1,result1);  
  57.     for_each(ide.begin(),ide.end(),display<int>());// 0,1,2,3,2,3,2,3,2不是预期的 0,1,2,3,2,3,4,5,6  
  58.     cout<
  59.       
  60.       
  61.       
  62.     return 0;  
  63. }   

【注意】如果以vector 容器替代deque容器则每种情况都正确，因为vector迭代器其实是个源生指针，调用的copy()算法以mommove()执行实际复制。

copy_backward(first，last，result);  //逆向复制，将迭代器first - last位置的元素逆向复制到 从result-1开始的逆向区间

补充：

        原型：void *memmove( void  * dest, const   void  * src, size_t  count );

　　 用法：#include 或#include 　　

        功能：由src所指内存区域复制count个字节到dest所指内存区域。　　

        说明：src和dest所指内存区域可以重叠，但复制后dest内容会被更改。函数返回指向dest的指针。采取先拷贝再复制的方式，有效解决了dest和src区域重叠问题　　

        相关函数：memset、memcpy、strcpy 参考博文：点此进入

实例

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. int main()  
  4. {  
  5. 　 char s[]="Golden Global View";  
  6.    memmove(s,s+7,strlen(s)+1-7);  
  7.    printf("%s",s);  
  8. 　　    
  9. 　 return 0;  
  10. }  

六，Set方法

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5. using namespace std;  
  6.   
  7. template <class T>  
  8. struct display  
  9. {  
  10.     void operator()(const T &x)  
  11.     {  
  12.         cout<" ";  
  13.     }  
  14.       
  15. };  
  16. int main()  
  17. {  
  18.     int ia1[]={1,3,5,7,9,11};  
  19.     int ia2[]={1,1,2,3,5,8,13};  
  20.       
  21.     multiset<int> s1(ia1,ia1+6);  
  22.     multiset<int> s2(ia2,ia2+7);  
  23.     for_each(s1.begin(),s1.end(),display<int>());  
  24.     cout<
  25.     for_each(s2.begin(),s2.end(),display<int>());  
  26.     cout<
  27.       
  28.     multiset<int>::iterator first1 = s1.begin();  
  29.     multiset<int>::iterator last1 = s1.end();  
  30.     multiset<int>::iterator first2 = s2.begin();  
  31.     multiset<int>::iterator last2 = s2.end();  
  32.       
  33.     cout<<"union of s1 and s2: ";  
  34.     //两个集合合并，相同元素个数取 max(m,n)。   
  35.     set_union(first1,last1,first2,last2,ostream_iterator<int>(cout," "));  
  36.     cout<
  37.       
  38.     first1=s1.begin();  
  39.     first2=s2.begin();  
  40.     cout<<"Intersection of s1 and s2: ";  
  41.     //两个集合交集，相同元素个数取 min(m,n).  
  42.     set_intersection(first1,last1,first2,last2,ostream_iterator<int>(cout," "));   
  43.     cout<
  44.       
  45.     first1=s1.begin();  
  46.     first2=s2.begin();  
  47.     cout<<"Intersection of s1 and s2: ";  
  48.     //两个集合差集 就是去掉S1中 的s2   
  49.     set_difference(first1,last1,first2,last2,ostream_iterator<int>(cout," "));   
  50.     cout<
  51.        
  52.     first1=s1.begin();  
  53.     first2=s2.begin();  
  54.     cout<<"Intersection of s1 and s2: ";  
  55.     //两个集合对称差集：就是取两个集合互相没有的元素 。两个排序区间，元素相等指针后移，不等输出小的并前进   
  56.     //相同元素的个数 abs(m-n)   
  57.     set_symmetric_difference(first1,last1,first2,last2,ostream_iterator<int>(cout," "));   
  58.     cout<
  59.       
  60.       
  61.     return 0;  
  62. }  

七，其他算法（运算逻辑相对单纯的算法）

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5. #include    
  6.   
  7.   
  8. using namespace std;  
  9.   
  10. template <class T>  
  11. struct display  
  12. {  
  13.     void operator()(const T &x)const  
  14.     {  
  15.         cout<" ";   
  16.     }   
  17.       
  18. };   
  19.   
  20. struct even  
  21. {  
  22.     bool operator()(int x)const  
  23.     {  
  24.         return x%2?false:true;   
  25.     }   
  26. };  
  27.   
  28. class even_by_two  
  29. {  
  30. private:  
  31.     static int _x; //注意静态变量   
  32. public:  
  33.     int operator()()const  
  34.     {  
  35.         return _x+=2;   
  36.     }      
  37.       
  38. };  
  39. int even_by_two::_x=0;   
  40.   
  41. int main()  
  42. {  
  43.     int ia[]={0,1,2,3,4,5,6,6,6,7,8};  
  44.     vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));  
  45.       
  46.     //找出iv之中相邻元素值相等的第一个元素   
  47.     cout<<*adjacent_find(iv.begin(),iv.end())<
  48.     cout<<*adjacent_find(iv.begin(),iv.end(),equal_to<int>())<//仿函数  
  49.       
  50.     cout<//统计6的个数   
  51.     cout<int>(),7))<//统计小于7的元素的个数 :9个  
  52.       
  53.     cout<<*find(iv.begin(),iv.end(),4)<//返回元素为4的元素的下标位置  
  54.       
  55.     cout<<*find_if(iv.begin(),iv.end(),bind2nd(greater<int>(),2))<//返回大于2的第一个元素的位置：3  
  56.       
  57.     vector<int> iv2(ia+6,ia+8);//6 6  
  58.       
  59.     for(int i=0;i
  60.       cout<" ";   
  61.         
  62.     cout<
  63.     //返回iv序列中 iv2序列 出现的最后一个位置（再往后三个位置的值）：8   
  64.     cout<<"find_end:"<<*(find_end(iv.begin(),iv.end(),iv2.begin(),iv2.end())+3)<
  65.      //返回iv序列中 iv2序列 出现的最后一个位置（再往后三个位置的值）：7  
  66.     cout<<"find_first_of:"<<*(find_first_of(iv.begin(),iv.end(),iv2.begin(),iv2.end())+3)<
  67.       
  68.        
  69.      for_each(iv.begin(),iv.end(),display<int>());   
  70.      cout<
  71.        
  72.      //遍历整个iv2区间并执行 even_by_two操作   
  73.      generate(iv2.begin(),iv2.end(),even_by_two());  
  74.      for_each(iv2.begin(),iv2.end(),display<int>());   
  75.      cout<
  76.        
  77.      //遍历区间（给出起点和长度），对每个遍历元素执行even_by_two操作   
  78.      generate_n(iv.begin(),3,even_by_two());  
  79.      for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长   
  80.      cout<
  81.        
  82.      //删除元素6 尾端可能有残余数据   
  83.      remove(iv.begin(),iv.end(),6);  
  84.      for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长   
  85.      cout<//8 10 3 4 5 7 8 6 6 7 8 (最后四个是残留数据)   
  86.         
  87.      //去除value 然后将一个容器的元素复制到另一个 容器。仍然可能有残留元素   
  88.       vector<int> iv3(12);//重新申请空间  
  89.       remove_copy(iv.begin(),iv.end(),iv3.begin(),6);  
  90.       for_each(iv3.begin(),iv3.end(),display<int>()); //由于_X是static 所以接着 增长   
  91.       cout<//8 10 3 4 5 7 8 7 8 0 0 （最后两个是残留元素）   
  92.         
  93.       //将小于6的元素 "删除" iv 此时为 8 10 3 4 5 7 8 6 6 7 8   
  94.       remove_if(iv.begin(),iv.end(),bind2nd(less<int>,6));  
  95.       for_each(iv1.begin(),iv1.end(),display<int>()); //由于_X是static 所以接着 增长   
  96.       cout<//8 10 7 8 6 6 7 8 6 7 8 (最后三个是残留元素)   
  97.         
  98.         
  99.       //将小于7的元素 "删除"  iv3元素：8 10 3 4 5 7 8 7 8 0 0 （最后两个是残留元素）  
  100.       remove_copy_if(iv.begin(),iv.end(),iv3.begin(),bind2nd(less<int>,7));  
  101.       for_each(iv3.begin(),iv3.end(),display<int>()); //由于_X是static 所以接着 增长   
  102.       cout<//8 10 7 8 7 8 7 8 8 0 0（最后三个残留元素）   
  103.         
  104.         
  105.      return 0;   
  106. }   

第二段算法示例：

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5.   
  6. using namespace std;  
  7.   
  8. template <class T>  
  9. struct display  
  10. {  
  11.     void operator()(const T &x)const  
  12.     {  
  13.         cout<" ";   
  14.     }   
  15.       
  16. };   
  17.   
  18.    
  19. int main()  
  20. {  
  21.     int ia[]={8,10,7,8,6,6,7,8,6,7,8};  
  22.     vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));  
  23.       
  24.     //将容器中6 替换为 3   
  25.     replace(iv.begin(),iv.end(),6,3);  
  26.     for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长   
  27.     cout<//iv:8 10 7 8 3 3 7 8 3 7 8   
  28.       
  29.     vector<int> iv2(12);   
  30.     //将容器中3 替换为 5 放入另一个容器   
  31.     replace_copy(iv.begin(),iv.end(),iv2.begin(),3,5);  
  32.     for_each(iv2.begin(),iv2.end(),display<int>()); //由于_X是static 所以接着 增长   
  33.     cout<//iv2:8 10 7 8 5 5 7 8 5 7 8 0（最后y一个残留元素）   
  34.         
  35.     //将容器中小于 5 替换为 2   
  36.     replace_if(iv.begin(),iv.end(),bind2nd(less<int>(),5),2);  
  37.     for_each(iv.begin(),iv.end(),display<int>()); //由于_X是static 所以接着 增长   
  38.     cout<//iv:8 10 7 8 2 5 7 8 2 7 8   
  39.   
  40.     //将容器中小于 5 替换为 2   
  41.     replace_copy_if(iv.begin(),iv.end(),iv2.begin(),bind2nd(equal_to<int>(),8),9);  
  42.     for_each(iv2.begin(),iv2.end(),display<int>()); //由于_X是static 所以接着 增长   
  43.     cout<//iv2:9 10 7 8 2 5 7 9 2 7 8 0(最后一个残留元素)   
  44.       
  45.     //逆向重排每一个元素 (倒置)   
  46.     reverse(iv.begin(),iv.end());   
  47.     for_each(iv.begin(),iv.end(),display<int>());  
  48.     cout<//iv:8 7 2 8 7 5 2 8 7 10 8  
  49.       
  50.     //逆向重排每一个元素 (倒置)   
  51.     reverse_copy(iv.begin(),iv.end(),iv2.begin());   
  52.     for_each(iv2.begin(),iv2.end(),display<int>());  
  53.     cout<//iv2:8 10 7 8 2 5 7 8 2 7 8 0 (最后一个残留元素)    
  54.      
  55.     // 互换元素  [bigin,middle)  [middle,end)   
  56.     rotate(iv.begin(),iv.begin()+4,iv.end());  
  57.     for_each(iv.begin(),iv.end(),display<int>());  
  58.     cout<//iv:7 2 2 8 7 10 8 8 7 2 8   
  59.          
  60.     // 互换元素  [bigin,middle)  [middle,end)   
  61.     rotate_copy(iv.begin(),iv.begin()+5,iv.end(),iv2.begin());  
  62.     for_each(iv2.begin(),iv2.end(),display<int>());  
  63.     cout<//iv2:10 8 8 7 2 8 7 2 2 8 7 0 (最后一个是残留元素)   
  64.       
  65.       
  66.     //在iv中查找 子序列 2 8 第一次出现的位置的元素   
  67.     int ia2[3]={2,8};  
  68.     vector<int> iv3(ia2,ia2+2);  
  69.     cout<<*search(iv.begin(),iv.end(),iv3.begin(),iv3.end())<//2   
  70.       
  71.     //在iv中查找 2个8 出现的第一个位置的元素   
  72.     cout<<*search_n(iv.begin(),iv.end(),2,8)<//8   
  73.       
  74.     //在iv中查找 3个小于8 出现的第一个位置的元素   
  75.     cout<<*search_n(iv.begin(),iv.end(),3,8,less<int>())<//7  
  76.       
  77.     swap_ranges(iv3.begin(),iv3.end(),iv.begin());  
  78.     cout<<"iv:";   
  79.     for_each(iv.begin(),iv.end(),display<int>());//iv:2 8 2 8 7 10 8 8 7 2 8   
  80.     cout<
  81.     cout<<"iv3:";   
  82.     for_each(iv3.begin(),iv3.end(),display<int>()); //iv3: 7 2   
  83.     cout<
  84.         
  85.     //全部减2   
  86.     transform(iv.begin(),iv.end(),iv.begin(),bind2nd(minus<int>(),2));  
  87.     for_each(iv.begin(),iv.end(),display<int>());//0 6 0 6 5 8 6 6 5 0 6   
  88.     cout<
  89.       
  90.      //两个区间元素相加然后放到 iv上   
  91.     transform(iv.begin(),iv.end(),iv.begin(),iv.begin(),plus<int>());  
  92.     for_each(iv.begin(),iv.end(),display<int>());  
  93.     cout<//0 12 0 12 10 16 12 12 10 0 12  
  94.       
  95.        
  96.      return 0;   
  97. }   

第三段算法示例：

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5.   
  6. using namespace std;  
  7.   
  8. template <class T>  
  9. struct display  
  10. {  
  11.     void operator()(const T &x)const  
  12.     {  
  13.         cout<" ";   
  14.     }   
  15.       
  16. };   
  17. struct even  
  18. {  
  19.     bool operator()(int x)const  
  20.     {  
  21.         return x%2?false:true;   
  22.     }   
  23. };  
  24.    
  25. int main()  
  26. {  
  27.     int ia[]={0,1,2,3,4,5,6,6,6,7,8};  
  28.     vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));  
  29.     vector<int> iv2(ia+4,ia+8);//4 5 6 6  
  30.     vector<int> iv3(15);  
  31.       
  32.     cout<<*max_element(iv.begin(),iv.end())<
  33.     cout<<*min_element(iv.begin(),iv.end())<
  34.   
  35.     //判断iv2中元素是否都出现在 iv中   
  36.     cout<
  37.        
  38.     //iv 和iv2合并到iv3中   
  39.     merge(iv.begin(),iv.end(),iv2.begin(),iv2.end(),iv3.begin());   
  40.     for_each(iv3.begin(),iv3.end(),display<int>());  
  41.     cout<
  42.       
  43.     //符合条件的 放到前面，不符合条件的放到后面   
  44.     partition(iv3.begin(),iv3.end(),even());  
  45.     for_each(iv3.begin(),iv3.end(),display<int>());  
  46.     cout<
  47.       
  48.     //去除连续并且重复的元素   
  49.     unique(iv.begin(),iv.end());   
  50.     for_each(iv.begin(),iv.end(),display<int>());  
  51.     cout<
  52.       
  53.       
  54.     //去除连续并且重复的元素   
  55.     unique_copy(iv.begin(),iv.end(),iv3.begin());   
  56.     for_each(iv3.begin(),iv3.end(),display<int>());  
  57.     cout<
  58.       
  59.       
  60.      return 0;   
  61. }   

八，复杂算法示例（解释在源码中）

[cpp]  view plain  copy
 print ?
  1. #include   
  2. #include   
  3. #include   
  4. #include   
  5.   
  6. using namespace std;  
  7.   
  8. struct even //是否是奇数   
  9. {  
  10.     bool operator()(int x)const  
  11.     {  
  12.         return x%2?false:true;   
  13.     }   
  14.       
  15. };   
  16. template<class T>   
  17. struct display  
  18. {  
  19.     void operator()(T &x)const  
  20.     {  
  21.         cout<" ";   
  22.     }   
  23.       
  24. };   
  25.   
  26. int main()  
  27. {  
  28.     int ia[] = {12,17,20,22,23,30,33,40};  
  29.     vector<int> iv(ia,ia+sizeof(ia)/sizeof(int));  
  30.       
  31.     //返回可以插入的第一个位置   
  32.     cout<<*lower_bound(iv.begin(),iv.end(),21)<//22   
  33.     cout<<*upper_bound(iv.begin(),iv.end(),21)<//22   
  34.     //返回可以插入的最后一个位置   
  35.     cout<<*lower_bound(iv.begin(),iv.end(),22)<//22   
  36.     cout<<*upper_bound(iv.begin(),iv.end(),22)<//23  
  37.       
  38.     //二分查找某个元素，返回是否找到   
  39.     cout<//1  
  40.     cout<//0   
  41.        
  42.     //生成下一个排列组合（字典序）   
  43.     next_permutation(iv.begin(),iv.end());   
  44.     for_each(iv.begin(),iv.end(),display<int>());  
  45.     cout<
  46.        
  47.     prev_permutation(iv.begin(),iv.end());   
  48.     for_each(iv.begin(),iv.end(),display<int>());  
  49.     cout<
  50.       
  51.     //打乱顺序   
  52.     random_shuffle(iv.begin(),iv.end());   
  53.     for_each(iv.begin(),iv.end(),display<int>());  
  54.     cout<
  55.       
  56.     //找出最小的4个元素 放在前四个 后面顺序不一定有序   
  57.     partial_sort(iv.begin(),iv.begin()+4,iv.end());   
  58.     for_each(iv.begin(),iv.end(),display<int>());  
  59.     cout<
  60.       
  61.     //排序（缺省为递增排序）   
  62.     sort(iv.begin(),iv.end());  
  63.     for_each(iv.begin(),iv.end(),display<int>());  
  64.     cout<
  65.       
  66.      //排序（设置为递减）   
  67.     sort(iv.begin(),iv.end(),greater<int>());  
  68.     for_each(iv.begin(),iv.end(),display<int>());  
  69.     cout<
  70.       
  71.     iv.push_back(22);  
  72.     iv.push_back(30);  
  73.     iv.push_back(17);  
  74.       
  75.       
  76.     //排序并保持原相对位置   
  77.     stable_sort(iv.begin(),iv.end());   
  78.     for_each(iv.begin(),iv.end(),display<int>());  
  79.     cout<//12 17 17 20 22 22 23 30 30 33 40   
  80.       
  81.     pairint>::iterator,vector<int>::iterator> pairIte;  
  82.     //返回等于22的一个小区间   
  83.     pairIte = equal_range(iv.begin(),iv.end(),22);   
  84.     cout<<*(pairIte.first)<//lowerbound 22   
  85.     cout<<*(pairIte.second)<//upperbound 23  
  86.       
  87.       
  88.     //这里返回一个空区间   
  89.     pairIte = equal_range(iv.begin(),iv.end(),25);   
  90.     cout<<*(pairIte.first)<//lowerbound 30   
  91.     cout<<*(pairIte.second)<//upperbound 30  
  92.        
  93.      //打乱顺序   
  94.     random_shuffle(iv.begin(),iv.end());   
  95.     for_each(iv.begin(),iv.end(),display<int>());  
  96.     cout<
  97.       
  98.     //将小于iv.begin+5的放到左边   
  99.     nth_element(iv.begin(),iv.begin()+5,iv.end());   
  100.     for_each(iv.begin(),iv.end(),display<int>());  
  101.     cout<
  102.       
  103.     //将小于iv.begin+5的放到右边   
  104.     nth_element(iv.begin(),iv.begin()+5,iv.end(),greater<int>());   
  105.     for_each(iv.begin(),iv.end(),display<int>());  
  106.     cout<
  107.       
  108.     //排序   
  109.     stable_sort(iv.begin(),iv.end(),even());  
  110.     for_each(iv.begin(),iv.end(),display<int>());  
  111.     cout<
  112.       
  113.       
  114.     return 0;   
  115. }  

你可能感兴趣的:(C++)

  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码） mmz1207 c++csp
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • 20个新手学习c++必会的程序 输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
    示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】 汉子萌萌哒 CCFnoi算法数据结构c++
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南c++数据结构stl
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
  • JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式androidjava常用设计模式
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
  • c++ opencv4.3 sift匹配 图像处理大大大大大牛啊 图像处理opencv实战代码讲解opencvsiftc++opencv4特征点
    c++opencv4.3sift匹配main.cppintmain(){vectorkeypoints1,keypoints2;Matimg1,img2,descriptors1,descriptors2;intnumF
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南C++修炼全景指南c++list链表stl
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
  • c++ 内存处理函数 heeheeai c++开发语言
    在C语言的头文件中，memcpy和memmove函数都用于复制内存块，但它们在处理内存重叠方面存在关键区别：内存重叠:memcpy函数不保证在源内存和目标内存区域重叠时能够正确复制数据。如果内存区域重叠，memcpy的行为是未定义的，可能会导致数据损坏或程序崩溃。memmove函数能够安全地处理源内存和目标内存区域重叠的情况。它会确保在复制过程中不会覆盖尚未复制的数据，从而保证数据的完整性。效率:
  • 【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】 XWWW668899 C++基本概念c++c语言开发语言青少年编程
    文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
  • C++常见知识掌握 nfgo c++开发语言
    1.Linux软件开发、调试与维护内核与系统结构Linux内核是操作系统的核心，负责管理硬件资源，提供系统服务，它是系统软件与硬件之间的桥梁。主要组成部分包括：进程管理：内核通过调度器分配CPU时间给各个进程，实现进程的创建、调度、终止等操作。使用进程描述符（task_struct）来存储进程信息，包括状态（就绪、运行、阻塞等）、优先级、内存映射等。内存管理：包括物理内存和虚拟内存管理。通过页表映
  • metaRTC5.0 API编程指南(一) metaRTC metaRTCc++c语言webrtc
    概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
  • sublime个人设置 bawangtianzun sublimetext编辑器
    如何拥有jiangly蒋老师同款编译器(sublimec++配置竞赛向）_哔哩哔哩_bilibiliSublimeText4的安装教程（新手竞赛向）-知乎(zhihu.com)创建文件自动保存为c++打开SublimeText软件。转到"Tools"（工具）>"Developer"（开发者）>"NewPlugin"（新建插件）。在打开的新文件中，粘贴以下代码：importsublimeimport
  • Rust是否会取代C/C++？Rust与C/C++的较量 AI与编程之窗 源码编译与开发rustc语言c++内存安全并发编程代码安全性能优化
    目录引言第一部分：Rust语言的优势内存安全性并发性性能社区和生态系统的成长第二部分：C/C++语言的优势和地位历史积淀和成熟度广泛的库和工具支持性能优化和硬件控制丰富的行业应用社区和行业支持第三部分：挑战和阻碍学习曲线现有代码库的迁移成本生态系统和工具链的完善度社区和人才培养行业应用和推广法规和标准化第四部分：未来趋势和可能性行业趋势教育和人才培养兼容和共存行业标准化企业支持和应用开源社区和生态
  • python可以制作大型游戏_python能做游戏吗-python能开发游戏吗 靖dede python可以制作大型游戏
    python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
  • Python开发游戏？也太好用了吧 七步编程 工具Githubpythonpython游戏开发语言
    程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
  • Go编程语言前景怎么样？参加培训好就业吗 QFdongdong
    Go语言专门针对多处理器系统应用程序的编程进行了优化，使用Go编译的程序可以媲美C或C++代码的速度，而且更加安全、支持并行进程。不仅可以开发web,可以开发底层，目前知乎就是用golang开发。区块链首选语言就是go,以-太坊，超级账本都是基于go语言，还有go语言版本的btcd.Go的目标是希望提升现有编程语言对程序库等依赖性(dependency)的管理，这些软件元素会被应用程序反复调用。由
  • OpenCV图像处理技术（Python）——入门 森屿_ opencv
    ©FuXianjun.AllRightsReserved.OpenCV入门图像作为人类感知世界的视觉基础，是人类获取信息、表达信息的重要手段，OpenCV作为一个开源的计算机视觉库，它包括几百个易用的图像成像和视觉函数，既可以用于学术研究，也可用于工业邻域，它于1999年由因特尔的GaryBradski启动，OpenCV库主要由C和C++语言编写，它可以在多个操作系统上运行。1.1图像处理基本操作
  • linux gcc 格式,Linux下gcc与gdb简介 神奇的战士 linuxgcc格式
    gcc编译器可以将C、C++等语言源程序、汇编程序编译、链接成可执行程序。gdb是GNU开发的一个Unix/Linux下强大的程序调试工具。linux下没有后缀名的概念。但gcc根据文件的后缀来区别输入文件的类别：.cC语言源代码文件.a由目标文件构成的库文件.C、.cc、.cppC++源码文件.h头文件.i经过预处理之后的C语言文件.ii经过预处理之后的C++文件.o编译后的目标文件.s汇编源码
  • 浅谈openresty 爱编码的钓鱼佬 nginxopenresty运维
    熟悉了nginx后再来看openresty，不得不说openresty是比较优秀的。对nginx和openresty的历史等在这此就不介绍了。首先对标nginx，自然有优劣一、开发难度nginx：毫无疑问nginx的开发难度比较高，需要扎实的c/c++基础，而且还需要对nginx源码比较熟悉，开发效率慢，比如实现一个类似echo的功能，至少要上百行代码。而openresty只需要一句ngx.say
  • Lua 与 C#交互 z2014z luac#开发语言
    Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
  • Java【泛型】 SkyrimCitadelValinor Java基础java
    Java泛型的概述不同类的数据如果封装方法相同，不必为每一种类单独定义一个类，只需定义一个泛型类，减少类的声明，提高编程效率。通过准确定义泛型类，可避免对象类型转换时产生的错误。泛型又提供了一种类型安全检测机制，只有数据类型相匹配的变量才能正常的赋值，否则编译器就不通过。Java中的泛型与C++类模板的作用相同，但是编译方式不同，Java泛型类只会生成一部分目标代码，牺牲运行速度，而C++的类模板
  • 解线性方程组 qiuwanchi
    package gaodai.matrix; import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class Test { public static void main(String[] args) { Scanner scanner = new Sc
  • 在mysql内部存储代码 annan211 性能mysql存储过程触发器
    在mysql内部存储代码 在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。 先看优点： 1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。 2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。 3 可以简化代码的维护和版本更新。 4 可以帮助提升安全，比如提供更细
  • Android使用Asynchronous Http Client完成登录保存cookie的问题 hotsunshine android
    Asynchronous Http Client是android中非常好的异步请求工具 除了异步之外还有很多封装比如json的处理，cookie的处理 引用 Persistent Cookie Storage with PersistentCookieStore This library also includes a PersistentCookieStore whi
  • java面试题 Array_06 java面试
    java面试题 第一，谈谈final, finally, finalize的区别。 final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
  • 网站加速 oloz 网站加速
    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教. 1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。 2、采用Gzip对网页进行压缩；    GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
  • 正确书写单例模式 随意而生 java 设计模式 单例
    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。 　　懒汉式，线程不安全 　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
  • 单例模式 香水浓 java
    懒汉  调用getInstance方法时实例化 public class Singleton { private static Singleton instance; private Singleton() {} public static synchronized Singleton getInstance() { if(null == ins
  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" AdyZhang apachehttp server
    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2" 每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。 解决方法确保几处： 1、停止IIS启动 2、把端口80改成其它 （譬如90，800，，，什么数字都好） 3、防火墙(关掉试试) 在运行处输入 cmd 回车，转到apa
  • 如何在android 文件选择器中选择多个图片或者视频？ aijuans android
    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传 但是android原生态的sdk中，只能一个一个的进行选择和上传。 我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个 处理方法 官方的图片选择器(但是不支持所有版本的androi，只支持API Level
  • mysql中查询生日提醒的日期相关的sql baalwolf mysql
    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
  • MongoDB索引文件破坏后导致查询错误的问题 BigBird2012 mongodb
    问题描述： MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。 解决方案：   使用脚本，重建MongoDB所有表的索引。 var names = db.getCollectionNames(); for( var i in names ){ var name = names[i]; print(name);
  • Javascript Promise bijian1013 JavaScriptPromise
            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。 一.认识Promises         “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程 bit1129 zookeeper
       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是     public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
  • 【Java命令三】jstack bit1129 jstack
    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump   [hadoop@hadoop sbin]$ jstack Usage: jstack [-l] <pid> (to connect to running process) jstack -F
  • jboss 5.1启停脚本　动静分离部署 ronin47
    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
  • UI之如何打磨设计能力? brotherlamp UIui教程ui自学ui资料ui视频
      在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。 1.找到自己的方式 如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
  • 三色旗算法 bylijinnan java算法
    import java.util.Arrays; /** 问题： 假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序， 您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳 子上进行这个动作，而且一次只能调换两个旗子。 网上的解法大多类似： 在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
  • 警告:No configuration found for the specified action: \'s chiangfai configuration
    1.index.jsp页面form标签未指定namespace属性。 <!--index.jsp代码--> <%@taglib prefix="s" uri="/struts-tags"%> ... <s:form action="submit" method="post"&g
  • redis -- hash_max_zipmap_entries设置过大有问题 chenchao051 redishash
    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑   #define ZIPMAP_BIGLEN 254 #define ZIPMAP_END 255     /* Return th
  • select into outfile access deny问题 daizj mysqltxt导出数据到文件
    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/ 为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。 授权的语句如下： grant select on armory.* to rn
  • phpexcel导出excel表简单入门示例 dcj3sjt126com PHPExcelphpexcel
    <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE);   if (PHP_SAPI == 'cli') die('This example should only be run from a Web Brows
  • 美国电影超短200句 dcj3sjt126com 电影
    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up!
  • Java访问远程服务 dyy_gusi httpclientwebservicegetpost
        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
  • Maven的settings.xml配置 geeksun settings.xml
    settings.xml是Maven的配置文件，下面解释一下其中的配置含义： settings.xml存在于两个地方： 1.安装的地方：$M2_HOME/conf/settings.xml 2.用户的目录：${user.home}/.m2/settings.xml 前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。
  • ubuntu的init与系统服务设置 hongtoushizi ubuntu
    转载自：  http://iysm.net/?p=178 init Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。 ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。 运行
  • 跟我学Nginx+Lua开发目录贴 jinnianshilongnian nginxlua
    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。    目录 第一章 安装Nginx+Lua开发环境 第二章 Nginx+Lua开发入门 第三章 Redis/SSDB+Twemproxy安装与使用 第四章 L
  • php位运算符注意事项 home198979 位运算PHP&
    $a = $b = $c = 0; $a & $b = 1; $b | $c = 1  问a,b,c最终为多少?   当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0 但是位运算符是不会改变变量的值的，例如： $a=1;$b=2; $a&$b;  这样a,b的值不会有任何改变
  • Linux shell数组建立和使用技巧 pda158 linux
    1.数组定义 　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。 　　 2.数组读取与赋值 　　得到长度： 　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
  • hotspot源码(JDK7) ol_beta javaHotSpotjvm
    源码结构图，方便理解：   ├─agent                            Serviceab
  • Oracle基本事务和ForAll执行批量DML练习 vipbooks oraclesql
    基本事务的使用： 从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚 select * from account; -- 创建一张账户表 create table account( -- 账户ID id number(3) not null, -- 账户名称 nam
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他