STL: (Standard Template Library) 标准模板库

使用其中的算法，需要#include <algorithm>

*max_element函数找最大元素  *min_element函数找最小元素

#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
    int n[]={1,4,22,3,8,5};
    int len=sizeof(n)/sizeof(int);
    cout<<*max_element(n,n+len)<<endl;
    cout<<*min_element(n,n+len)<<endl;
    return 0;
}

也可以对vector 操作

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int main()
{
    int n[]={1,4,2,3,5,0};
    vector<int>v(n,n+sizeof(n)/sizeof(int));//sizeof(n)/sizeof(int)是求数组n的长度
    cout<<*min_element(v.begin(),v.end())<<endl;//最小元素
    cout<<*max_element(v.begin(),v.end())<<endl;//最大元素
    return 0;
}

注：vector 初始化的几种方法

//vector<T> v(n,i)形式，v包含n 个值为 i 的元素
 vector<int> ivec(10,0);

 //vector<T> v(v1)形式，v是v1 的一个副本
 vector<int> ivec1(ivec);


//vector<T> v(n)形式，v包含n 个值初始化的元素
 vector<int> ivec2(10);

//数组初始化vector
 int iarray[]={1,2,3,4,5,6,7,8,9,0};
 //count： iarray数组个数
 size_t count=sizeof(iarray)/sizeof(int);
 //int数组初始化 ivec3
 vector<int> ivec3(iarray,iarray+count);

//string数组初始化 svec1
 string word[]={"ab","bc","cd","de","ef","fe"};
 //s_count： word数组个数
 size_t s_count=sizeof(word)/sizeof(string);
 //string数组初始化 svec1
 vector<string> svec1(word,word+s_count);

//用 back_inserter 函数
 vector<int> ivec4; //空对象
 fill_n(back_inserter(ivec4),10,3); //10个3 填充ivec4.
}

C++ Reference对于memset的定义为：

void * memset ( void * ptr, int value, size_t num );

对int类型的内存区域进行初始化，ptr的类型是int*，举例说明一下:

• 将内存初始化为0

  memset(ptr,0,sizeof(ptr));

• 将内存初始化为-1

memset(ptr,0xff,sizeof(ptr));

    因为按照字节进行填充，那么value值为0xff，将会把内存的每个字节都填充为0xff，则int值的区域为全1，那么int值就是-1。

• 将内存初始化为极大值

memset(ptr,0x3f,sizeof(ptr));

   这段初始化代码初始出来的int值大小是1061109567

• 使用memset初始化vector

  vector<int> vec(10,1);
  memset(vec.data(),0,vec.size()*sizeof(int));

   

排序算法 sort

• 对基本类型的数组从小到大排序: 

               sort(数组名+n1，数组名+n2）;     

               将数组中下标范围为[n1,n2)的元素从小到大排序。下标为n2的元素不在排序区间内

• 对元素类型为T的基本类型数组从大到小排序：

              sort(数组名+n1，数组名+n2,greater<T>()）;

• 用自定义的排序规则，对任何类型T的数组排序

              sort(数组名+n1，数组名+n2,排序规则结构名());

              排序规则结构的定义方式：

struct 结构名 { 
    bool operator()( const T & a1,const T & a2) { 
            //若a1应该在a2前面，则返回true。 
            //否则返回false。 
    } 
};

二分查找算法

 STL提供在排好序的数组上进行二分查找的算法
binary_search   lower_bound    upper_bound

用binary_search进行二分查找

• 在从小到大排好序的基本类型数组上进行二分查找

       binary_search(数组名+n1，数组名+n2,值);

       查找区间为下标范围为[n1,n2)的元素，下标为n2的元素不在查找区间内

       在该区间内查找"等于"值”的元素，返回值为true(找到）或false(没找到）

       "等于"的含义： a 等于 B <=>  a < b和b < a都不成立

• 在用自定义排序规则排好序的、元素为任意的T类型的数组中进行二分查找

       binary_search(数组名+n1，数组名+n2,值，排序规则结构名()); 

       查找时的排序规则，必须和排序时的规则一致！

用lower_bound二分查找下界

• 在对元素类型为T的从小到大排好序的基本类型的数组中进行查找

        T * lower_bound(数组名+n1,数组名+n2,值);

返回一个指针 T * p;

       *p 是查找区间里下标最小的，大于等于"值" 的元素。如果找不到，p指向下标为n2的元素

• 在元素为任意的T类型、按照自定义排序规则排好序的数组中进行查找

      T * lower_bound(数组名+n1,数组名+n2,值,排序规则结构名());

返回一个指针 T * p;
     *p 是查找区间里下标最小的，按自定义排序规则，可以排在"值"后面的元素。如果找不到，p指向下标为n2的元素

用upper_bound二分查找上界

• 在元素类型为T的从小到大排好序的基本类型的数组中进行查找

         T * upper_bound(数组名+n1,数组名+n2,值);

返回一个指针 T * p;
         *p 是查找区间里下标最小的，大于"值"的元素。如果找不到，p指向下标为n2的元素

• 在元素为任意的T类型、按照自定义排序规则排好序的数组中进行查找

        T * upper_bound(数组名+n1,数组名+n2,值,排序规则结构名());
 返回一个指针 T * p;
       *p 是查找区间里下标最小的，按自定义排序规则，必须排在"值"后面的元素。如果找不到，p指向下标为n2的元素